Nvidia announces native GPU programming in Rust(developer.nvidia.com) |
Nvidia announces native GPU programming in Rust(developer.nvidia.com) |
@fast def calc(x,y):pass
If so, that's really big.
And to add the Next natural strp - custom codegen for simulating gpu compute and memory without Nvidia gpu.
This is more promising: https://github.com/Rust-GPU/rust-gpu/
GPU kernels want explicit memory control and as little go-runtime like overhead as possible
It's just that gpus have no general purpose usage .. for ai, it's basically all about perf.
Of course some cross platform stuff can be made for modest acceleration, but the state of the art is always going to be out of reach.
The best way to program GPUs is face up to the reality that they are not the same machine as the CPU, write your kernels in separate files, and launch them manually, like in Metal, OpenCL, and D3D12, etc. These days we even have DSLs like Triton that make kernel writing much more ergonomic than anything you would hope to achieve in Rust.
People have been doing that all the time for every kind of codebase. It's just part of the business. I don't see how it's worth having any emotions or opinions about it. Seems like you are wasting your energy.
Are win32 APIs proprietary? So you decide to use them, use a wrapper/UI framework, or don't develop for Windows. Easy choice.
Developing for embedded devices? So you read the manufacturers manual and implement based on the spec, use some sort of HAL if they are available, or you don't have a job. Even simpler.
Ironic, seeing as that is an opinion about it. Also weird telling people in an online discussion forum not to have opinions.
It's called foresight. The ability to see that vendor lock-in is against our long-term interests.
Your windows comparison is apt - now we have tons of software tied to windows, making it hard to leave that spyware-infested OS.
Because we're engineers? Hackers? You know, hacker news?
We're supposed to care about the craft, its quality, and our long-term interests, not the shareholders, not the executives, and definitely not Microsoft and NVIDIA. If you really think this isn't a discussion worth having then you don't belong in this domain at all and you shouldn't be an engineer.
What is your ecosystem where this is true? Embedded or industrial, maybe?
I'm guessing you assume other people also use the same windows or embedded systems you're referring to. That's an insane thought: nobody would use this if they had any chance, and you intentionally chose this misery.
Obviously, you don't need to live this way. You can be free. Breathe.
Yes. And crap. Not in my code bases.
Some people only care about the easiest path to their pay check. Some people actually care about software engineering. I tend to prefer the latter but hamstrung by the former.
The having it all in a single file is mostly an artefact of the fact that it is C++, because C++ is single file at a time compilation. In D (which is multiple files in a single compiler invocation) with DCompute (which targets CUDA and OpenCL with upcoming support for Vulkan and Metal), you are required to write the kernels in a separate module, but you get all the benefits of the compiler complaining when you mess up _and_ the expressivity of "launch me this kernel".
Shouldn't this be alleviated by the current code generation machines?
> The best way to program GPUs is face up to the reality that they are not the same machine as the CPU, write your kernels in separate files, and launch them manually
Not to mention that this is a completely sane way to use CUDA as well.
Turns out when one isn't ideologically against something they aren't willing to put up with a lesser experience just for the cause.
As an example of you how can use it to deploy real models there is this project doing ASR and TTS: https://github.com/dropbox/nspeech .
Finally, I am also going to be switching the inferencing part of Witchcraft from current Candle on MacOS and OpenVINO on Windows to just Candle with Neso; https://github.com/dropbox/witchcraft
Yes, I also prefer doing it that way, but in Cuda with the driver API. Allows you to handle kernels like shaders, including editing and hot-reloading at runtime.
The reason I'm sticking with CUDA is because it's by far the most convenient API to use, without nonsense like 50-liners to alloc memory or the need to manage descriptors, bindings, queue families, etc.
I was there when the OpenCL committee was deciding on that sort of stuff.
As I recall, and it's been two decades and a lot of sleepless nights since then, there was real pushback at the time against OpenGL-style default bindings. So folks didn't want to establish an implicit command queue or any other default objects attached to other objects. Part of it is because OpenGL was perceived as clumsy and passé, some of it was because it is not friendly to multi-threaded applications.
Those first meetings were a shitshow full of tension, implicit threats from Apple, and backroom deals. Kudos to Neil Trevett for chairing the group; I I bet it wasn't fun for him either.
Isn't that how CUDA code is normally written?
i'm currently using vulkan, and HLSL via dxc. which should be portable but it's not.
apple refuses to support vulkan, and relies on moltenvk and there's a bunch of OS/hardware/driver differences no matter what you do, that you'll probably have to feature test for, and compile a few different versions of your code no matter what you do
i think if you're doing something that you don't have to distribute to customers, just picking one stack and getting locked in has some appeal.
it leaves you vulnerable to lockin. but, especially in the age of ai, "claude, port this to vulkan" seems like a good enough defense against that
Obviously you need to check if CUDA is available before trying to execute kernels, or it will error out.
Ive essentially followed that paradigm with Python and C. I start out writing Python code. If I need something to run fast, I build a standalone C application that either reads from a file or listens on a socket, and just invoke it from Python. No need to write the entire thing in Rust and deal with all its semantics when it will be at best like 2% faster.
Genuine question...why not just type "crap"? It's not even that much of a curse, but I've never really understood the point of self-censorship. If you don't want to curse then you could just use a non-curse word.
See YouTube.
Some platforms disallow certain words. In order to bypass that, some people use the asterisks. That's just as one possible answer to your question; there can be many different reasons for self-censorship, but to me the most logical one is when one tries to work around crappy restrictions, such as on terrible reddit (they killed old.reddit recently; I retired before that due to moderators being insane, but I also said that if old.reddit is gone, I am gone anyway - the requirement to now log in, totally defeats old.reddit com's usecase. Then again reddit went downhill many years before that already, so not a real loss.)
Otherwise cr*p is just as good as crap, shit, horseshit, poopoo or such.
edit: * replaced with \* as HN interprets asterisks as formatting for emphasis. Thx latexr for informing me
alternately, perhaps he meant to match all of cp, crp, crrp, crrrp, and so on. the dude might really like regexes.
/s
I believe we'll be left to wonder.
What would be even cooler though would be for GPU vendors to start giving us the user manual. An I mean the real user manual, that explains how to use their piece of metal when all you have is that piece of metal. That means a precise description of the wire protocols, the data format of the buffers we send to & get from the GPU, the ISA of the cores we have access to, the relevant performance characteristics…
In other words, enough information to write a state-of-the-art driver for any OS. That would be cool.
The analogy is Tensorflow 5-10 years ago. It is popular, and there are lots of material on it. You quickly learn from talking to people that due to whims, a collection of reasons, people's love of consensus that no one is recommending it; new people are not learning it. In this case, the Torch analogy is the Burn lib.
(disclosure: I am a contributor)
Just today I was reading Stanley Druckenmiller’s op ed in WSJ. This dude is like 80 and has made billions of dollars, and he got Claude to write his op ed???
Unbelievable. And the tells are so obvious, yet people still love the Claude-like quips and odd grammatical choices that read like halfway asshole halfway mid-sentence confusion.
Since I can write a simple compiler to target x64 machine code, it should be possible to write one to target my GPU.
Though, I'm certain that vendor lock is probably more profitable for them.
And in that context NVIDIA had every motivation to keep their SDK somewhat abstracted higher up the chain and fully under their control and then be free to innovate in the lower bits. And this served them well as well as their customers.
My sense is that now with agent driven development this is basically evaporating. Agents are capable of at least prototyping/writing kernels for any hardware and ISA. e.g. OpenAI built their own custom hardware and ISA for it and then set agents loose on it writing kernels and claims great success. At least they're claiming this. And from my own experiences as a n00b entering this space, I can believe it.
TLDR I don't think vendor lock on the software side is going to work out for them as a strategy.
But luckily for them they continue to have really good hardware and good access to semiconductor fabrication. But just look at HotChips 2026 a couple weeks ago and look at the huge variety of new inference hardware coming down the pipe which looks completely unlike NVIDIA/CUDA.
Secondly, When an issue occurs with a kernel or you want to write your own custom kernel in Rust, now we need to diagnose if the problem came from either cuda-oxide (SIMT), Rust's side, CUDA or Tile (If you decide to choose the Tile track).
Another dependency into the list and course everything is open source except CUDA itself. So any issue that happens on the CUDA level, you are forced to wait for them to fix it.
Thank you NVIDIA - for once (not twice though - you've given us nothing but despair for Linux+GPU).
With this system, how do we specify whether dependencies are needed to be compiled for the CPU, GPU, or both?
----
Technically I don't know really care whether it's multiple files or one, I just want to make sure we are not reinventing a shittier version of CFG. What they are providing looks to me like:
1. explicitly annotate some things as `cfg(GPU)` or ungated (both)
2. unlabeled means annotated `cfg(not(GPU))` by definitely
Put this way, this has nothing to do with GPUs, and just has to do with creating some crate-local CFG shorthanded. Great! Let's do that first, get a solid foundation, and then come back to whatever is remaining for CUDA Rust.
On a side note, Vulkan has extension to launch CUDA kernels: https://docs.vulkan.org/refpages/latest/refpages/source/VK_N...
You write kernels in a Rust DSL using #[cube], it supports WebGPU through WGSL and Vulkan through SPIR-V, along with CUDA, AMD via ROCm, and Metal. (disclosure: I am a contributor)
But only for compute tasks. So, practically an alternative language to write compute shaders in.
Note: Cuda-oxide is similar to Cudarc's host component, but uses a rust-style kernel dialect. Advantage: Share structs between host and device. Disadvantage: Trading standard Cuda kernels for a new, WIP dialect.
I haven't tried the tile API yet; looking forward to it.
The last time I checked, Cuda Oxide was Linux only, and required Async; these are why I haven't tried it yet.
Seems more ergonomic in general though, both approaches they share, compared to cudarc, and less build infrastructure and fiddling with environments, which is great.
Damn even Nvidia is putting out fully Claude-written articles.
It's been this way for 25 years and I don't see it changing.
I believe the need to quickly iterate dropped significantly since we got shaders. I would bet in fact there was few such iterations in the last 10 years. Crazy increases in computing power of course, but big breaking changes in the actual ISA? I'd be surprised.
> to release silicon with bugs that can be papered over with software fixes
Yeah that's actually one of my goals. Only ship stuff that works on pain of embarrassment and prohibitive recall costs. It's crazy hard. It's how CPUs are shipped.
> and undoubtedly to charge more for what looks like a hardware feature but actually is a software feature.
Again, that's good. Such pricing tactics are scummy, I want to end them.
---
Now of course, those reasons you cited are reasons for the vendor not to do what I'm pretty sure is very good for the consumer. I propose we force them. We could start small. Mice and keyboards first. Then printers. Then webcams, wifi modules... until we get to GPUs themselves.
But hi, if I spent $10,000 on a piece of hardware, let me program the metal, thanks.
We could possibly make an exception for open source software, or only forbid the distribution of the relevant drivers, or limit the applicability of that law to specific hardware: hard drives, mice, printers, web cams... or GPUs.
Anyway, that should be disruption enough.
this has nothing to do with becoming more general purpose (GPUs will never be general purpose - it's literally physically impossible).
Well in that sense, neither will CPUs. Just like GPUs, some workloads are better left to other kinds of hardware.
Why "even Nvidia"?
They are fully behind using AI for basically everything.
What's next? "Damn, even McDonald's is putting out unhealthy food"
It points to friction rather than cost economics. Same reason we are always surprised why multi billion dollar product companies with millions of install base prefer electron instead of a native app.
- "Launch is checked"
- "Question is asked"
- "The implementation answers"
- "The model wants"
- "The results name"
- "The connection surfaces"
- "The prompt wires"
- "The feature rides the mechanism"
Every single fucking thing is alive, wants things, and does things.
It's terrible. Infuriating. I want to rip my eyeballs out reading this filth. All. The. Time. "The anger is real".
It's so horrible. The human element has been completely removed and replaced by..... mediocre.
We are still much better at writing in a way that doesn't waste other people's time.
Plenty of us share the same opinion on doing reviews of AI generated code.
Kinda the same with language/technology stuff - it can be a great tutor and it can scaffold other parts of a project for you. It can give you feedback and let you focus on the interesting parts.
I guess the motivation itself may be hard because of the fear of it taking over much of our jobs, but having this kind of help/feedback is pretty cool for the sake of learning things just because they are interesting!
Please don't. I've had all of Codex, Claude and Gemini convincingly tell me absolutely wrong stuff, pointing it out with easily verifiable example they come up with more and more weird reasons.
Things don't become correct simply because most sources are again - easily and logically verifiable - wrong. This already was a plague when people "just googled" stuff and effectively returned with the most SEO optimized answer. Now we have very convincingly written instances all over the place.
If these were singular instances I wouldn't be so worried, but if you are learning it already is very easy to learn something wrong. This is why back in the days when people still used physical books to learn new things it was a good idea to check first which books are actually recommended. There have been a lot of "experts" that wrote things they clearly misunderstood but worked for all the examples in their books.
To give a common example for both the backend and frontend devs, that isn't about a specific projects. LLMs and Google searches frequently turn out wrong results regarding CORS caching and how it works in relation to domains/hostnames. The circumstances under which Content-Disposition work are another example. I think a lot of wrong statements that LLMs are "convinced" about are due to wrong statements (sometimes in otherwise correct response) of popular Stack Overflow answers.
It's saddening how much wrong "common knowledge" exists in the industry. I have been bitten by a lot of these, but it feels when people don't even actually code and think anymore this will just rise forever.
And that sounds scary but the way I got over the fear is by realizing there are many things that I do very well but I do not know their internals very well. Driving is an example. I barely understand what the steering wheel, clutch or brake pedals do. I have driven over 130,000 Kms and I will perhaps drive more than double that in the next many years.
I have been building software since PHP/Drupal days. Got into AWS S3 as a beta user. Adopted Memcached (and MQ) in 2008 out of necessity. Then Python/Django for 10 years. Then Rust. And tons of JS/TS. I owe a lot to my curiosity. I believe we can keep learning what we need and still delegate most of programming to agents.
I had LLMs write a pile of cuda-rust code and they were quite competent at it. Ported a bunch of (C++) CUDA kernels over, and ground away on them til they got equivalent performance
https://github.com/rdaum/eider/tree/main/backends/cuda-oxide
And mostly just DeepSeek 4.1 Flash, too. Not even a frontier model.
Sorry.
There were humans far superior than you for writting Rust before LLM, now there's a LLM. The only difference is price and time execution.
You get an awesome teacher (LLM) ready to answer all your questions about Rust.
And you still find excuses not to learn it ?
At some point, just realize you've been lazy to learn it and LLMs are just an excuse.
Does that mean someone else gets say I'm being ironic because I'm selectively literal in order to be rhetorical? Well, okay, I guess it's harder now.
Where do you think you are ?
Most of us are in tech/IT/research the population in the spectrum here is orders of magnitude bigger than the avg on real life. SO yeah people will be literal in order to be rhetorical. Not even selectively, this is the one site where you NEED to use /s unironically.
Your job as a CUDA engineer isn't to decide whether or not a proprietary API/compiler is the right call. Your boss made that choice for you when they hired you, and you accept the tradeoff if you want to keep working there. It's like someone protesting Dotnet because they wish they spent the rest of their life working with Perl instead. You can do that, but it's a completely different job with different pay grades and demands.
The disadvantages of writing them together are listed in the various parent posts. But some code authors really like the convenience of having the two in the same file.
Compared to OpenVINO (I tried ONNX runtime too, but never got it produce correct outputs with my quantized models) it is very nice to be able to build the exact kernels I need, at the quantization settings and precision that works for the models I have and with the custom operators required (speech models do a lot of non-standard stuff), run from a single set of sources, and not have to ship a hefty third-party DLL, and having to deal with their memory leaks and other stability issues.
I asked Google's Gemini if Julia can run on GPU unmodified without annotations, pragmas, intrinsics or similar manually-managed friction, and it said yes, but that data types must be swapped out for GPU-backed types:
If your code is written using vector/matrix operations, broadcasting, or standard linear algebra functions, it can run on the GPU entirely unmodified. You only need to change the input data type to a GPU-backed array (e.g., swapping a CPU Array for a CuArray from CUDA.jl).
# A standard Julia function — completely agnostic to hardware
function custom_math!(C, A, B)
@. C = sin(A) + 2 * B # Normal broadcasted operation
end
# Running on the CPU:
A_cpu = rand(1000)
B_cpu = rand(1000)
C_cpu = similar(A_cpu)
custom_math!(C_cpu, A_cpu, B_cpu)
# Running on the GPU (Unmodified function!):
using CUDA
A_gpu = CuArray(A_cpu)
B_gpu = CuArray(B_cpu)
C_gpu = similar(A_gpu)
custom_math!(C_gpu, A_gpu, B_gpu) # Automatically compiles to native PTX!
This is the direction we should be going. So while Nvidia's Rust port is an important first step, it's an evolutionary rather than revolutionary achievement. But that's all Nvidia can really do now, since it's locked into its own paradigm like Intel/Microsoft and has gotten too big to think outside the box.
Edit: PTX in its example stands for Parallel Thread Execution, the Virtual Machine (VM) Instruction Set Architecture (ISA) created by NVIDIA for its GPUs, which works similarly to Java byte code.
Edit 2: Broadcasting is a feature in Julia that allows you to apply a function or mathematical operation element-by-element across arrays of different shapes and sizes, without writing manual loops. In Julia, broadcasting is syntactically indicated by a dot (.) placed before an operator or function name (e.g., sin.(x) or .+). <- I was today years old when I learned the term for this
You need Objective-C, Swift, and Metal is a C++14 dialect with extensions.
You may refer to the C++ bindings, which still not obviate the need for the C++14 dialect in the shaders, and it only works, because there is a shim to call the Objective-C runtime from C++.
Likewise there are DirectX COM interfaces that are really only usable from Visual C++ COM extensions, and the HLSL semantics depend very much on which compiler is being used, hence why there is finally a language reboot going on.
(if a platform is serious about Bad Words for whatever reason (moral?) they would also forbid character replacements; ultimately it's the intent, not the word itself, that they try to steer with rules like that)
I guess I never understood censorship when it’s plainly obvious what you’re censoring. Anyone who can read will clearly know that it said “crap”, so I don’t see how it’s fundamentally different than just saying the word. You still put the word into my brain.
https://developer.nvidia.com/gpugems/gpugems2/part-iv-genera...
Slashdot's spirit shall live somewhere, no? Rent is all-time high and it can only afford here, for now.
I can't compare it to changes I've seen in CPU architecture since then. Maybe like: Compare the NES with its 6502 and per-cartridge mappers vs. a IBM 386 PC. Now repeat that shift 2 or 3 more times.
How many times since we got shaders? And when exactly? I bet each change takes longer to come than the last. I mean, GPUs are increasingly general purpose nowadays. Sure they're optimised to specific kinds of embarrassingly parallel problems, but as more and more of their capabilities move out of the fixed pipeline to shaders, the need to change lessens.
In the GeForce3 era, the registers got complicated enough they resembled tiny "pixel shaders", but under the hood it was still a small struct held in registers. Vertex shaders were 1 to 128 asm instructions executed strictly linearly.
In the G80 era we got "general purpose shaders." But, they still depend heavily on the fix function pipeline for their dispatch/scheduling and I/O.
These days, everything is basically a dressed-up compute shader. The shared-memory SRAM is front-and-center in your attention. Dispatch and scheduling are manual and complicated. GPUs are transitioning into tensor evaluators.
So, maybe today we can start considering talking about planning committee meetings about stability. But, what I've observed is that this has been a request for a few decades now. And, in hindsight it would not have worked out in the past. Moving forward, maybe it would work out OK today for a while. But, I don't see the rate of change in GPUs slowing down any time soon. Wouldn't be surprised if we're racing towards some Cerebras + Tensor Cores + FPGA near future.
Still waiting for this revolution of amazing 10x software! It's been 10 months since Everything Changed in November, surely the 10x pragmatists could have leveraged their effective 8 years of development time? Or maybe we'll move the goalposts again and say that actually, Everything Changed with Astra, we'll just need to wait another three months?
Which is a collective term for transactionalists, short-termists and profit-seekers of all kinds in this case.
Design by committee is a real phenomenon. And people in a committee know that, but they are also helpless.
And the Mojo standard library has been open source for over a year.
It’s all open source. Go check it out!
Before SPIR was a thing in OpenCL, Khronos could not understand why anyone would care about anything else other than C99, or why supporting Fortran on GPUs was at all relevant.
Secondly, from the competition only Intel cares about SYCL with their own sugar on top, OpenAPI.
AMD hasn't cared one second about it.
You may mention Codeplay, which is anyway an Intel owned company since 2022.
As for Vulkan, it doesn't have neither the features, nor the tooling that CUDA enjoys, it is the usual putting up with using LEGOs from different brands, with various pin sizes, that is so common with Khronos.
People and companies are hungry for knowledge about people's reactions, but the modern internet DOES NOT give an accurate image of people's views.
Only devs think it isn't coming for them, it is empowering and nothing else will happen, no team reductions, nah how come.
They both have a variety of sizes but it's a similar range and they have similar contents.
that would be pretty cool, you can just get your entire day's calories from one burger
Not saying you're wrong, but my career got a lot less frustrating when I started focusing more on the product and less on the ergonomics of the implementation. If you need to build a house and the customer isn't willing to pay for brick, you use vinyl siding.
I recently started learning CUDA and parallel programming paradigms.
1) code gets split between a host part that goes through your normal compiler, and a device part that goes through the GPU compiler. You may as well write the kernels separate and compile them via a separate compilation step, and keep your trusted host compiler for the host-side code.
2) data needs to move between the host and devices via explicit buffer transfers and synchronization steps, CUDA tries to hide this with annotated pointers, but it is really easier to think about those as just buffers that you allocate and transfer IMO, instead of trying to transparently share pointers between host and device like CUDA does.
3) kernel launches can we wrapped in a function similar to:
void RunKernel(const char *kernel_name, size_t width, size_t height, size_t depth);
Instead of the funky <<< >>> syntax that CUDA for C/C++ imposes. The problem is that once you start putting that in your code, it stops being C++ and stops being portable to non-CUDA GPUs. The launching and grid settings can be a bit hard to grasp at first, but sugarcoating that in bastardized C++ syntax does not absolve from having to understand it eventually.
So a good place to start might be an OpenCL or Metal primer, depending on the hardware you have available. D3D12 (and probably Vulcan too) makes this much harder than it should be, with too much boilerplate but is overall a mature and well-designed API should you wish to develop for Windows. Starting with WebGPU might also be good these days. It has a very different shader language than the others, but the rest of the concepts are similar, and it has a strong emphasis on making things async, which is what you want for performance anyways.
Claude/Codex should be able to get you moving very quickly.
From: https://docs.nvidia.com/cuda/cuda-programming-guide/01-intro...
I've never understood why we can't just expose the GPU ISA directly the way the CPU does. It's all getting compiled down at the end of the day so someone has to write a compiler for it either way. We'd be substantially better off IMO if it was all built directly into LLVM and then let middleware sort out the details.
Naturally plenty of folks rather use software that doesn't take advantage of the hardware they paid for.
CPUs manage this by changing the internal micro-architecture, but historically GPUs only needed to support a graphics API and used that abstraction layer to freely change the hardware.
I will.
Can these be wrong? Certainly. So can humans. Many of your examples are of humans being wrong. That doesn't make LLMs - or humans - useless. The fact that they are not infallible is not a reason to avoid using them and I'm not going to throw out a tool that has been incredibly valuable to me because someone on the internet got some bad CORS advice.
Questions like "What do these lines of code do?" or "How does this fit into the big picture?" or "Wait, this doesn't make sense?" are rarely answered by the source.
This is a bit fresher in my mind in the math domain, but I don't think it is any different in any number of other domains, including coding. I've been working through a math textbook, gotten confused about how the author gets from step 2 to step 3, taken a picture of the text, and had AI explain it to me - it almost always gives me a much better understanding of what is going on and helps make things so much clearer. There is a level of interactivity that can't exist in a book or other "source" of information.
I think there is a bit of tension when it comes to learning and sometimes the struggle itself is informative, but there is a reason people hire tutors and go to classes taught by teachers vs just reading a textbook, and cutting yourself off from a tool because you've seen it be wrong about something seems like a silly mistake.
No it hasn't. The human element is still there, prompting the LLM. The change is that the human is happily accepting the first thing they get rather than critically looking at it and seeing a problem.
Humans are seeing either a shortcut to go faster (accepting low quality to move on immediately; reasonable if they're short on time) or a shortcut to lowering effort (accepting low quality because they don't care; not so reasonable but probably has a deeper root cause).
They are just better at hiding it or configuring Claude.
I have several skills that reformat text to remove AI-speak tells.
I put the "humanized" output through Pangram and it still comes out as 100% AI generated.
Nice one!
Which year shall we count as 1 AD (Anno Delirii (or should it be Darii))?
I do find it a little amusing, because commenters stopped criticizing my cursing the moment I started getting a good chunk of karma here. I remember in 2016 someone criticized me for using the term "shitposting"...I don't think I've gotten that kind of criticism since 2016 though.
It’s one thing if it’s some funny commentary channel avoiding those words, but what bothers me is the true crime YouTubers. In the subject of true crime, rape and murder are just things that are probably going to come up, and when they refuse to use the appropriate language, it comes off as infantilizing, which is weird considering that my actual YouTube account is over 18, let alone the viewer using it.
Advertisers ruin everything, I guess.
Basically someone comes up with something which is nonsensical, but plausible. Like believing that their videos are unpopular because they said the word "rape" and the algorithm magically got them, rather than because their videos suck. Then someone else sees that and starts thinking it is true. It silently spreads across the population.
I've seen this in organisations, where new recruits haven't been properly trained. Someone has come up with a method which is wildly incorrect and illegal, but plausible. The other new people around them have copied them. They've become slightly more experienced people, they've taught the next round of new people.
Before you know it, half of the organisation is doing something hilariously wrong, and they all sincerely believe it is the right way of doing it, because everyone does it. It's just self-reinforcing at that point.
In psychology that kind of thing is referred to as "superstition".
More specifically, "superstition" in this sense refers to the phenomenon of copying someone else's successful approach to a problem you have. (In your example, getting views on youtube.) Since you don't know what parts of their approach matter, you copy the effective parts and the ineffective parts equally.
YouTube used to demonetise profanity unless it was mild. YouTube would demonetise profanity in the first X number of seconds of the video. These rules change and have been relaxed of April last year, but generally these rules still exist.
There isn't a hard filter if you say "suicide" you automatically get it. However it increases the likely hood of demonetisation. So people avoid it to be safe. So you end up with people using stupid euphemisms all the time.
That can be quite confusing. You had German mustache-man, Russian mustache-man, French mustache-man (Petain), French small-mustache-man (de Gaulle), Spanish small-moustache-man (Franco)
> Launching kernels manually is an error prone PITA which I believe is the principle reason for CUDA's popularity.
Write python code, ask any llm to translate it to C, then compile the C code - if it produces errors or fails to run, ask LLM to fix it. Then take it a step further and ask it produce machine code, and repeat the procedure.
Then RL the llm on the above, and you basically have a Python -> Machine code compiler. If you cover every single possible python syntax, every single possible C syntax, every possible standard library call, and all the compiler optimization examples (all of which is a final set), you should get something that is extremely accurate.
I appreciate that we can upload SPIR-V directly. The API still feels overly obtuse but it's not so bad.
SYCL gets close but is language specific.
I grew up texting. But in the 90s any profanity filters could just be turned off in settings.
I've never had texts censored by texting providers, they're not supposed to read texts in the first place (at least around here).
Leaves more to the imagination.
To have an unclosed asterisk replacing characters in a word? I've only ever seen that as a way to bypass censorship. This spans communications from people currently in their 40s down to 20.
(although it is a half-joke since it's definitely not a curse word imo)
I'll admit, it never once occurred to me that people might be using censored characters to provide more emphasis that a word is a swear, but I guess it does indeed do that, at least to the writer. Whether that comes across to the reader, and whether the writer cares that their intention was understood... I'm not so sure.
The heck you talking about? How do you think we wrote software for the last 50 years?
And now with AI I’m using it to fact check Claude. And still reading it for myself to understand why other peoples code is written a certain way. It’s basically the most important thing to reference when coding.
Sure today Claude can just read the library code and tell you what a function does or how to do something. But it still won’t tell you why something is a certain way or won’t figure out specifically-designed usage patterns as reliably as the author telling you “this is an example of doing x”
I brushed up on the docs since I haven't touched it in a couple years, explained my understanding of the ob_* functions, and gave him a very brief demo on a PHP playground.
He could have asked any LLM to tell him what that chunk of code did, and to explain the three functions, and instead he reached out to me. That felt _good_. Talking shop has always been a good way for me to form connections, because the pressure to socialize becomes task-oriented and you start to learn about how people think and feel, and that opens up easier paths for actual connection. It was nice.
Just like the Old Internet still exists - niche websites, mailing lists, probably a BBS or two (likely more right?), the pre-LLM world will trudge on, for a time. I hope LLMs actually lead to good things for people in the long run, and for now I personally will remain sparse in my usage of them.
It is shocking how much of a differentiator this is. You will discover that the software you’re already using is much more capable than you realized.
I start with reading and exploring documentation first; with the codebase as a secondary tab.
When it’s not LLM generated, documentation is supposed to be easier to read and more insightful than code.
Speak for yourself. I read it.
https://support.google.com/youtube/answer/6162278?hl=en#Harm...
Creators are being careful don't want their video demonetised because once it gets the yellow flag, even if it is removed later they've lost the majority of monetisation.
The problem with providing direct proof of this is that YouTube moves the goalposts quite often and their auto moderation system is very inconsistent.
Practical computing is not and never has been an abstract pure concept. It’s about making machines built by corporations to do usefull things at scale.
There is no ”non proprietary” computing unless you make your own stack.
It’s even worse for CUDA. GPUs are expensive, and now you’re vendor locked. You’re between a rock and a hard place. Either spend millions in engineering time, or millions on price-gauged hardware.
This is wrong way around.
If you don’t support the platform your app runs on using the native api:s to the hilt your port is just bad.
If you actually want to support multiple platforms _you actually need to support_ them from the ground up.
This is speaking industrially and businesswise. A professional software business always has per-platform implementation resources. Or they have just one platform. Or they pretend they are multiplatform and then _everybody_ _daily_ fights with the problems this causes.
Obviously those elements that can be portable should be. It’s like Einsteins simplicity maxim - your codebase should be as portable as can be but not more.
” It’s even worse for CUDA…”
No these are just the business and market constraints. If this does not make sense for your offering then don’t use it. This feels like false FOMO - CUDA is not a silver bullet but it might be a specific solution to a specific problem.
Is this still true? eg, Shopify saying porting is now easy so no need for abstractions.
Not even close to being true. You can invoke syscalls directly, just needs a bit of reverse engineering. I wrote a bare metal libc library, with (not a whole lot of) effort I'm fully able to interface with the kernel/open windows etc. Fully statically linked, no libc, no win32, compiled on Linux executed on Windows.
The problem is this isn't really well documented _at all_, and I even ended up attempting to get in touch with the Windows kernel dev team to give me the actual internal syscalls/endpoints, but they refuse to cooperate. Which is why writing anything for Windows is entirely pointless.
There's nothing that can stop you from using syscalls in theory, but if you want your app to be portable across different OS versions, past and future, you'd better not.
Incidentally, syscalls would also break Wine. The way Wine works is basically by shipping their own versions of Windows DLLs, which express their operations in terms of Linux APIs. Because Windows programs don't rely on syscalls, and call all system functions via the system-provided libraries, the Wine loader can just link Wine's version and let the program work normally.
Do you want to keep reverse engineering the syscall ABI for every Windows edition and update ever? Do you want to ask your users to disable Windows Update?
Regardless, I don’t even understand how that’s relevant, since you’re still introducing a dependency on a proprietary ABI.
Just being totally honest this is how I read this comment when I insert context that seems important to me. I respect having principles but at some point there needs to be more value in practicality over your codebase not being locked into a proprietary framework at all.
The windows syscall API is yet another proprietary windows API. Sure - you can call it without loading any DLLs. But you're still calling into a proprietary windows API.
If you really hate calling proprietary windows APIs that much, maybe stop developing for windows? Develop software for linux. Or make your own kernel, or whatever. But if you keep developing software for windows, stop fighting it. Unless you have a very good reason, your software should try to fit in on its host platform. It should behave well, and work like other windows software.
It's like travel. If you fly to France, try to fit in. Maybe learn a bit of French before you go. If you hate France, don't go.
...your troubles are starting
One trade-off is even some obviously LLM text won't get detected by them, but they work really hard to ensure false positives are rare since a false accusation is much worse for society than someone getting away with LLM meatpuppetry.
(Addendum: As I recall, LLM-generated outputs roughly follow Zipf's law, but the distribution still tends to have some subtle distinctions vs human text; pretty interesting, but I don't know where I heard this, so nothing to cite. Sorry.)
But still, this is all very strange because it wasn't that many generations of AI models ago that AI writing was a lot better - I'm talking GPT 4.1, Claude 4.5, that sort of era.
Anthropic newsroom posts on the other hand are carefully constructed and well-written in a way that I have not seen demonstrated by LLMs yet, past or present. I expect that they have well-paid staff who are careful with every detail of their public communications. When you put it that way, it almost feels unfathomable that they wouldn't, doesn't it?
You need the documentation to know why certain things work a particular way, or to know why some relationships or methods are the way they are
Even now I wonder if I am allowed to type bitch here...
I guess we will find out.
And Re: CUDA: yes if it doesn’t make sense then dont use it. That’s sort of my whole argument. It might make some level of sense from a technical perspective, but that needs to be balanced with business risk. I’m saying a lot of people aren’t doing the balancing right, which is why these new tools have value.
> Anthropic doesn't appear to use Claude for blog posts
My claim is literally the lack of evidence, which, yes, can't prove anything. This claim can be contested easily by showing evidence that they in fact, do appear to be using Claude to write prose in blog posts.
They said:
> Anthropic _absolutely_ does
Sounds pretty certain Anthropic is in fact, using Claude to write blog posts. Enough to emphasize "absolutely". That doesn't read like "I'm going off of vibes", that reads like "I can prove it". So, fine. Prove it. I don't believe it, and I want to hear the proof.
I'm skeptical, but it wouldn't be my first time being wrong. But flatly, if you make claims with this kind of certainty, yes I want to hear your proof.
My point in saying "Even Anthropic doesn't appear to be using Claude for blog posts" was not meant to be some striking revelation, I literally was considering it a prior to make another point. This on the other hand sure does sound like a striking revelation to me, that a lot of people across the Internet would be curious to hear. Like I'm sure these people would be interested:
https://www.reddit.com/r/ClaudeAI/comments/1wdfd92/are_anthr...
I will admit that I am unnecessarily aggressive sometimes, but I wouldn't have changed my response much in any case. If you're going to make a strong claim like this, I want your evidence, not your vibes. Otherwise, the claim should be a lot weaker.
I also realize that this sort of brashness upsets HN a bit, but it is what it is. I pandered comments for votes in my 20s a bit, time to grow up, sometimes people won't like you. Sometimes I feel something deserves a brash response.
We are starting to see results indicating cognitive decline due to AI in education, so no, we should do everything possible to ban it except for very limited fields.
LLMs aren't calculators or even computers, their generated output is too flexible, generic and basically starts replacing thinking.
Most likely they should only be allowed during late highschool years or just at university level, when people at least have a chance to learn how to research on their own.
Whether this is a widespread macro trend is another issue, and would be terryfying.
If true, however, it would reflect on the values of the organization: we have spent decades underpaying teachers, and doing a poor job of pretecting schools from frivoluos lawsuits. Add into that, districts have thrown money into new buildings, have been suckered by Big Tech to adopt their policies (common core was pushed by Big Tech and has been a distaster as well as computers in classrooms). As a nation (the USA) we can't get our act together for a rigorous national exam, etc etc.
Alabama is one state that requires the ACT. The mean score in Alabama is below 18/36. Wisconsin is another. Its students score on average about 1 point higher than the national average of 19.4/36.
If you prefer states that require the SAT, the mean SAT score of students from Delaware is less than 980/1600, about 50 points below the national average.
I'll leave it to others to argue about whether these exams are rigorous.
My hot take is that it's not really that terrible in the long run for work since I think LLMs will probably be nearly or actually AGI and better white collar workers than most humans within 5 years of today. But it is very funny and surreal in the meantime.
It is definitely bad for school, though. Kids IMO should actually be encouraged to use LLMs but not in or for class work outside of an AI best practices class. Probably stop giving them homework (90% will always try to find a way to make AI do it) and have them solve problems in class hours with no electronics so that they're forced to not defer learning. This will become even more important once we have AGI.
What if they don't?
> This will become even more important once we have AGI.
What if we achieve AGI in 50+ years? Should everyone live in this Kafkaesque world until then?
They initially implemented the Golang runtime directly on top of MacOS syscalls (not the C runtime library), just like they did on Linux - and then those syscalls changed, breaking Golang.
They had to switch to the official stable API which on MacOS is the C runtime library, not syscalls.
Findes der en Haddock/Egon Olsen tiradegenerator derude?
This doesn’t work for proprietary software that’s distributed as blobs and rarely updated, like say, video games. But that’s a minority of stuff on Linux. But not on windows.
Realistically, on Linux applications target specific API versions of frameworks. Like Qt 6, or GTK 3, or whatever. Then everything is compiled or dynamically linked at a per-distro level. The ABI compat can bite specifically when distros enforce strict dynamic linking. But then containerization technologies come in.
And there is a difference between API and ABI stability. For example, adding SSO to std::string in C++ broke ABI, not API. If you recompile it’s fine, everything works. If you don’t then it doesn’t.
That’s one of the biggest issues keeping Linux small on the desktop since nearly no commercial oriented company works that way.
But it looks like we will soon be able to „virtualize“ the dynamic loader so glibc has no say in this matter anymore.
That's literally the definition of it being stable. Programs written against an interface keep working despite the implementation changing. The Linux kernel also constantly changes internally but programs written against syscalls keep working, so it is stable; that fact doesn't stop being a fact just because I dislike perf_event_open(2) or whatever. This is all very basic and easy to understand.
> Dead wrong [...] if I want to release a binary _without relying_ on Win32
Then you are not using the Win32 ABI, are you?
Also, there are OS-provided shims in ntdll.dll (which, by the way, isn't a part of Win32 platform API, but a part of the NT kernel interface).
I mean _it's just work_. You don't need to invent anything. Just do the work.
What _is_ hard is when people run after silver bullets to avoid all this work.
Because people who don't understand software decide it would be cheaper to implement something only once. Or someone who does not really understand what they are doing insists that same C++ code runs automatically on all platforms.
AI has given the software engineers permit from the beancounters to do the sane thing.
Good software development orgs _have always_ done proper per platform ports.
Also - there is nothing wrong in supporting only one platform as such!
I really wonder why this was never fundamentally fixed. How performant a certain instruction on a specific platform is, how well it is supported and potential equivalents or sets of other instructions to emulate an equivalent are usually all very well understood.
So there should be some graph of operations which can transform any software from and to the specifics of each platform. Especially because firmware + compliers + platform abstracting libraries are basically already just that graph, although (usually?) to lossy to be applied in reverse. Add the recent developments in very large scale statistics to it and it'd probably be quite possible to transform from and to generic intent in the implementation to the uniqueness of each platform. E.g. the theming differences between a MacOS UI and a terminal application served over serial or the processing capabilities of a VLIW CPU compared to a FPGA or a GPU server.
Considering the enormous amount of work that went into compilers, better debugging and intermediate representations it seems like a huge missed opportunity nobody seriously asked the question whether information could be emitted that would allow for decompiling all the way back to the generic intent.
For example, if you have a program that just does raw math and pointer arithmetic and data structure manipulation —- that is, pure computation — then porting it to a different CPU might well be trivial. Just recompile. As long as your language toolchain supports it, this will Just Work.
But if your program works with the filesystem and sockets and threads, then it’s less likely to work. This is the promise of POSIX: if your program uses only what’s offered by the POSIX standard and uses those functions correctly, then it’s supposed to work on any POSIX-compliant system. Just recompile.
But if your program has a GUI, or does 3D graphics, or uses special methods for high-performance networking, or accesses gyroscopes or accelerometers or touch sensors, well then you have to do work to port. And notice that this work isn’t about which CPU instruction to use. It’s about figuring out —- deciding —- what the right thing to do is, for your app, given a slightly different set of available system capabilities.
Youtube is a lot more guilty of it though, as well as demonetizing.
YouTube has its problems but I don't think it's had quite as strong of an effect on language.