I strongly dislike CUDA. Once you have allowed that proprietary cr*p into your C++ codebase, it is very hard to get rid, and you end up with code that is either tied to a single vendor or an #ifdef hell, probably both.<p>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.
> Once you have allowed that proprietary cr*p into your C++ codebase<p>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.<p>Are win32 APIs proprietary? So you decide to use them, use a wrapper/UI framework, or don't develop for Windows. Easy choice.<p>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.
> I don't see how it's worth having any emotions or opinions about it.<p>Ironic, seeing as that is an opinion about it. Also weird telling people in an online discussion forum not to have opinions.
Oh, does that mean I get to say you're ironic because, literally, they didn't tell anyone to do anything. They said they didn't understand the worth of the opinion. You're interpretation is selectively literal in order to be rhetorical.<p>Does that mean someone else gets say <i>I'm</i> being ironic because I'm selectively literal in order to be rhetorical? Well, okay, I guess it's harder now.
> I don't see how it's worth having any emotions or opinions about it. Seems like you are wasting your energy.<p>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.
Many software engineers forget they're employee of a <i>business</i>.
> Are win32 APIs proprietary?<p>Yes. And crap. Not in my code bases.
The CPU on most machines is quite proprietary. I don’t understand this faux purity dogma.<p>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.<p>There is no ”non proprietary” computing unless you make your own stack.
Yes but there are business costs to using high-level proprietary tools and libraries. If you write your app using win32, you won’t be able to port is very easily. You’re also stuck with whatever bad or bizarre decisions Microsoft made.<p>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.
” If you write your app using win32, you won’t be able to port is very easily.”<p>This is wrong way around.<p>If you don’t support the platform your app runs on using the native api:s to the hilt your port is just bad.<p>If you actually want to support multiple platforms _you actually need to support_ them from the ground up.<p>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.<p>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.<p>” It’s even worse for CUDA…”<p>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.
Win32 is the most stable abi on the Linux desktop.
Dead wrong. Win32 (externally) only seems stable, but internally it changes between Windows releases. Win7 syscalls are completely different from Win11 syscalls, meaning if I want to release a binary _without relying_ on Win32 I need to provide full syscall mappings _for each and every Windows version_. This doesn't happen on Linux.
> only seems stable, but internally it changes<p>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.
<i>>> Win32 is the most stable abi on the Linux desktop.</i><p><i>> Dead wrong [...] if I want to release a binary _without relying_ on Win32</i><p>Then you are not using the Win32 ABI, are you?
I wonder which APIs you would use to port easily, because POSIX and Khronos aren't it either, as they are industry standards driven by companies where one has to pay for a seat at Open Group and Khronos offices.
> If you write your app using win32, you won’t be able to port is very easily.<p>Is this still true? eg, Shopify saying porting is now easy so no need for abstractions.
If you're going to make apps in windows, you need to call their proprietary API somehow. Maybe you do it via a wrapper library, or via electron or something. But that's the same thing, just with more indirection.
> If you're going to make apps in windows, you need to call their proprietary API somehow. Maybe you do it via a wrapper library, or via electron or something. But that's the same thing, just with more indirection.<p>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.<p>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.
That’s insane. Windows does not have a stable syscall ABI. The way you’re supposed to interact with the kernel is through the userspace library. Of course the kernel team refuses to cooperate.<p>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?<p>Regardless, I don’t even understand how that’s relevant, since you’re still introducing a dependency on a proprietary ABI.
The problem is much deeper than that. Most OSes' syscall ABIs are not stable and could change without warning. What is stable is the dynamically-loaded libraries, shipped as part of the system. Linux is the notable exception here; the Linux kernel project doesn't ship a libc, and Linus is very famously opposed to "breaking userspace."<p>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.<p>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.
> This isn’t even close to being true. Here’s a thing I did that made things way more complicated than is worth it for 99% of developers when there is a proprietary solution made so I do not need to worry about these things. Because it is so hard to work around it, it is entirely pointless to develop for one of the most used operating systems in the world.<p>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.
> Not even close to being true. You can invoke syscalls directly,<p>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.<p>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.<p>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.
Find a way to get ring 0 without touching any system APIs and you can just make your own APIs. My programs shall never say "please."
CUDA is not an API, CUDA is a language, so you cannot make that comparison.
CUDA is neither an API, nor a language, it is an ecosystem.
> The CUDA runtime is a special case of one of the libraries provided by the CUDA Toolkit. The CUDA runtime provides both an API and some language extensions to handle common tasks such as allocating memory, copying data between GPUs and other GPUs or CPUs, and launching kernels. The API components of the CUDA runtime are referred to as the CUDA runtime API.<p>From: <a href="https://docs.nvidia.com/cuda/cuda-programming-guide/01-introduction/cuda-platform.html" rel="nofollow">https://docs.nvidia.com/cuda/cuda-programming-guide/01-intro...</a>
Launching kernels manually is an error prone PITA which I believe is the principle reason for CUDA's popularity. Having the compiler give an error when you mess up is a huge benefit. But having the compiler allow you to express "I want to launch this kernel over a grid with these dimensions, with these arguments" as a single expression is where the vast majority of the value comes from.<p>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".
Having also played with Metal and WebGPU (at least years ago), I would say that CUDA is, amazingly, the best GPGPU API we have. Do I wish we had an open source parallel programming language as good or better than it? Yes. But asymmetrically hating on CUDA like this is how we continue to lag behind it in UX.<p>> 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<p>Not to mention that this is a completely sane way to use CUDA as well.
> 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,<p>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.<p>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>> 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><p>I was there when the OpenCL committee was deciding on that sort of stuff.<p>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.<p>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.
from what i can tell, you're going to be stuck with that no matter what you do<p>i'm currently using vulkan, and HLSL via dxc.
which should be portable but it's not.<p>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<p>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.<p>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
I don't mind CUDA, I do mind that all of the SDKs don't dynamically load the various CUDA shared libraries at runtime.. intertwining itself into your application linking process makes for extreme binary portability inconvenience.
> 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<p>Isn't that how CUDA code is normally written?
Yep.<p>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.
You could also use Mojo, one language for all targets.
Or julia if you want a much more mature ecosystem.
I fell in love with MATLAB (or GNU Octave for free since you really pay for toolboxes/packages) back around 2004, despite it warts. So I second Julia, which is similar, but is a more modern functional language instead of imperative.<p>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:<p><i>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).</i><p><pre><code> # 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!
</code></pre>
<a href="https://cuda.juliagpu.org/stable/" rel="nofollow">https://cuda.juliagpu.org/stable/</a><p>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.<p>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.<p>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
I highly recommend Julia for (scientific) GPU programming but it would be nice if there was a larger community and/or funding behind the GPU side of things. It has very few core devs for what it is.
Julia has had a great CUDA story for a few years now, and this about 9 days old. Rust rejects buffer aliasing at compile time using Rust's borrow checker, but shared memory in cuda-oxide currently requires unsafe, but then there's HuggingFace's Grout and mistral.rs, so yeah, Rust is picking up ground here on Julia. How is OpenCL's performance these days?
I began to lose interest after the acquisition. Have you been following along, are they still going to open source it?
The Mojo compiler has been open source for over a month now.<p>And the Mojo standard library has been open source for over a year.<p>It’s all open source. Go check it out!
I thought they already did and released the compiler source code under Apache 2.0.
Anyone here looking at Modular's offerings?
What is a proprietary crop?
Is this satire? D3D12 and Metal aren't any less proprietary than CUDA.
? I find it hard to see the issue here. Just put it in a separate file and call it?
yeah, just write a stub/wrapper around it and abstract. it's the classic coupling problem. nothing to do with CUDA
> I strongly dislike CUDA. Once you have allowed that proprietary cr*p<p>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.
I thought that cp*p is some kind of ugly cuda pointer declaration :D And being non-standard C++ syntax it wouldn’t compile.
Normative behavior has shifted due to pervasive censorship and surveillance.
* is used to give emphasis and show that they are using the word as curse word rather just calling it bad
It doesn't read as emphasis to me. It reads like the person is trying hard <i>not</i> to curse, and they think "crap" is a curse word. It's a little bit adorable, like I'm reading a comment from an obedient child.
I think a string of non-alphanumeric characters would work much better here, like "Once you have allowed that proprietary @#$&% into your C++ codebase”<p>Leaves more to the imagination.
In any context I've seen, asterisks are for wrapping formatting and said formatting it to add emphasis. So being in the habit of typing `<i>emphasised phrase</i>`, for italics - regardless of whether the platform parses markdown/similar formatting, e.g. SMS.<p>To have an unclosed asterisk replacing characters in a word? I've <i>only</i> ever seen that as a way to bypass censorship. This spans communications from people currently in their 40s down to 20.
i do this to put emphasis, i always type "h*ck".<p>(although it is a half-joke since it's definitely not a curse word imo)
But this isn't perceived as emphasis at all. If I wanted to emphasize something, I'd be more likely to use something like *bitch* or something along those lines. Replacing a letter with an asterisk comes across as self-censorship, which is pretty silly - just use a different word if you're that uncomfortable with swearing.
like for example, c*nt?
Maybe more like p**p, as in "that cunt p**ped in my yard"?<p>I'll admit, it never once occurred to me that people might be using censored characters to provide <i>more</i> 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.
What about ^#%& as was traditional in newspaper comics strips?
How about <i>"Pockmark!... Freshwater swabs!... Bully!.."</i> or <i>"Amoeba! Bashi-bazouks! Chowderheads! Certified Diplodocuses! Nyctalop! Ectoplasm!"</i>?
I was so disappointed when I tried reading tintin in other languages and found the dear captain was straight up using slurs in those. I wonder whether the english language ones have been edited over the years to remove that sort of thing
æselmassør, sortbørsgrosserer, søpindsvinefjæs, karnevalssørøver!<p>Findes der en Haddock/Egon Olsen tiradegenerator derude?
"Your mother was a hamster and your father smelt of elderberries!"
Known as grawlix or obscenicon.<p><a href="https://en.wikipedia.org/wiki/Grawlix" rel="nofollow">https://en.wikipedia.org/wiki/Grawlix</a>
Hah. Yeah, I agree. It's one of those things I admit is `lost in translation` for sure.
Because I know it is not technically crap, a lot of competent people worked on it, most with good intentions. I suppose it is better described as a cleverly designed Trojan horse than can infect your software and make that software become crap, in the sense that it becomes harder to maintain, increases code duplication, messes with your build system, ties your build system to platforms that have their toolchain binaries available, etc., etc., without bringing any long-term benefits over learning things the hard way.
The long term benefit is that there are more developers with CUDA experience available to hire than there are with any of the "hard ways" you mention.<p>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.
As someone only recently getting into HPC, what do you mean when you say learning things the hard way? What would you suggest?<p>I recently started learning CUDA and parallel programming paradigms.
For learning that may be a fine approach, but CUDA (in C++) really tries to hide what is going on behind the scenes, which is roughly:<p>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.<p>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.<p>3) kernel launches can we wrapped in a function similar to:<p>void RunKernel(const char *kernel_name, size_t width, size_t height, size_t depth);<p>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.<p>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.<p>Claude/Codex should be able to get you moving very quickly.
Thank you very much for the effort you put into your advice!! I think I will start with WebGPU (wgpu), even though I have an Apple Silicon Macbook. I would really prefer to work with Rust instead of C++ because I am not good with C++. (I believe) I am good with C, so my C++ code looks like C code, and I am kinda learning the differences as I learn CUDA, which is a terrible way to learn C++, I guess.
Platform may retroactively make up and enforce rules that makes your content violate terms (and remove them)<p>See YouTube.
I certainly dislike how everyone on YouTube is saying “SA” and “unalive” and “corn”.<p>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 <i>actual YouTube account</i> is over 18, let alone the viewer using it.<p>Advertisers ruin everything, I guess.
I don't think those filters are even real, I think it's just mass-hysteria. I call these kinds of behaviours "traditions", but I'm not sure if there's a better term for it.<p>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.<p>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.<p>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.
No it isn't mass hysteria. YouTube has a set advertiser friendly guideline. It will scan uploads and streams automatically.<p>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.<p>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.
> I call these kinds of behaviours "traditions", but I'm not sure if there's a better term for it.<p>In psychology that kind of thing is referred to as "superstition".<p>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.
Actually, I was a little too specific here - superstition also refers to copying your own successful approach.
I always associated the term “cargo culting” with that but I think that term has largely fallen out of fashion (probably for the best).
I am sure they are bullshit. Like when they mute cursing and "risky" speech, but when you enable autogenerated subtitles they show up there. Youtube knows what thay said regardless if it's censored or not. It's so fucking stupid
A (baseless) hypothesis: perhaps there are plenty of YouTube creators who use the proper, mature terminology but you never see their videos because the algorithm really is penalizing them for it...
It's become so bad that even quality history youtube channels are frequently using euphemisms like "moustache-man" instead of just saying "Hitler", to avoid their videos being buried by The Algorithm, and therefore cut severely into their viewership.
> even quality history youtube channels are frequently using euphemisms like "moustache-man" instead of just saying "Hitler"<p>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)
I think it's a win-win. Intelligent people easily knows what they're talking about, and the others don't get offended. /s
It may be to bypass censorship, rather than self-censorship. Some platforms block or shadowban comments with curse words. Not sure about this platform.
cause you might go to the eternal flames if you say a no-no word online
Because nanny states are tracking your keyboard nowadays.
> I've never really understood the point of self-censorship.<p>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.)
Not all crap is created equal, some needs censoring.
IMO cr*p and crap are both valid but separate swear words. People have a wide option to choose from when they want to swear, and people like variety (much much more than LLMs do). People also tend to influence each other with their usages: cr*p is popular because it is popular.<p>Otherwise cr*p is just as good as crap, shit, horseshit, poopoo or such.<p>edit: * replaced with \* as HN interprets asterisks as formatting for emphasis. Thx latexr for informing me
His kids were probably watching him type over his shoulder and he didn’t want to hear, “Daddy, what does crap mean?”
"Daddy, what does cr*p mean?" Kids aren't stupid and this self-censorship isn't protecting anyone from anything.<p>(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'd consider that a joke - but also zero issue using any words talking in front of kids. You might wish to explain them anyways.
I am arguing that they would ask that anyway.<p>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.
What if a toddler is browser HN and sees the curse word?
he could be a farmer and didn't want to type crop.<p>alternately, perhaps he meant to match all of cp, crp, crrp, crrrp, and so on. the dude might really like regexes.<p>/s
My guess is that jacobgorm will not reply. I would love a reply, because I want to understand how others think.<p>I believe we'll be left to wonder.
[flagged]
[dead]
Okay, so, GPUs are taking one more step towards being general purpose massively parallel machines. That's cool.<p>What would be even cooler though would be for GPU vendors to start giving us the user manual. An I mean the <i>real</i> user manual, that explains how to use their piece of metal <i>when all you have is that piece of metal</i>. 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…<p>In other words, enough information to write a state-of-the-art driver for any OS. <i>That</i> would be cool.
They don't release it because exposing a stable instruction set would kill their ability to quickly iterate, to release silicon with bugs that can be papered over with software fixes, as fixing bugs in chips is very expensive in terms of time to market, and undoubtedly to charge more for what looks like a hardware feature but actually is a software feature.<p>It's been this way for 25 years and I don't see it changing.
A stable instruction set would be nice.<p>But hi, if I spent $10,000 on a piece of hardware, let me program the metal, thanks.
How is this different than CPUs? I suppose in the last 5 years the architecture and tape has changed a lot as they move to make more LLM capable?
They don't need to do that to sell their hardware so why would they do that? On the other hand, they have strong incentives to not give you that level of access and information. The only way this will change is by having some disruption by way of a competitor who sells hardware with that feature as being a major reason why it takes off.
GPGPU <a href="https://en.wikipedia.org/wiki/General-purpose_computing_on_graphics_processing_units" rel="nofollow">https://en.wikipedia.org/wiki/General-purpose_computing_on_g...</a>
> GPUs are taking one more step towards being general purpose massively parallel machines<p>this has nothing to do with becoming more general purpose (GPUs will never be general purpose - it's literally physically impossible).
Since NVIDIA owns huggingface now and huggingface has the excellent Candle [1] crate for inference on Rust, this seems like a good step towards nice native Rust kernels.<p>[1] <a href="https://github.com/huggingface/candle" rel="nofollow">https://github.com/huggingface/candle</a>
I will give you an outsider's perspective on an analogy in this case. It is easy to see Candle as a ML crate to use for neural networks in rust. I have used it, and it works well.<p>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.
And to tie this back into GPU programming, Burn's backends use CubeCL, which lets you write compute kernels in a Rust DSL using #[cube], with a JIT compiler and autotuning machinery. It targets CUDA, AMD, Metal, Vulkan and WebGPU.<p>(disclosure: I am a contributor)
noob here - what's the benefit of this? Will using Rust lead to more optimal LLMs or code or both?
Nobody cares if kernels are written in Rust. Kernels were meant to be written in C, but if you want to go more high-level try Triton or a similar DSL that nicely abstract tile sizes etc.
kernels aren't meant to be written by any defined language. C is just a traditionally good default language that took over from assembly. No particular reason we have to stick with C.
That is exactly why OpenCL failed adoption, focusing on C, instead of being polyglot like CUDA.
SYCL is the natively polyglot counterpart, with practical implementations of it compiling down to the same sort of SPIR-V kernels as OpenCL. (OTOH, much of the current adoption on the open standards side seems to target the more widely supported SPIR-V compute shaders, via Vulkan compute.)
Not really, first of all it is for C++, not the range of languages supported by CUDA.<p>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.<p>Secondly, from the competition only Intel cares about SYCL with their own sugar on top, OpenAPI.<p>AMD hasn't cared one second about it.<p>You may mention Codeplay, which is anyway an Intel owned company since 2022.<p>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.
I have never seen a comment this gray
in all of hackernews' shitty UX decisions, gray unreadable comments is one of the worst ones
I haven't felt this popular since then 1990s when I was opposing Visual J++ and IIS.
oh no no no, this is going to break the CPP hold on AI and game dev.
I think it would be much nicer, although unrealistic at the moment given the number of combinations of GPU vendors and variety of hardware, to directly target the underneath GPU ISA machine code.<p>Since I can write a simple compiler to target x64 machine code, it should be possible to write one to target my GPU.<p>Though, I'm certain that vendor lock is probably more profitable for them.
I don’t know for sure but I’m pretty sure the ISA changes quite frequently for Nvidia.
My thoughts on this, as a person who has recently coming around to working in this space is that up to now the convenience and "simplicity" of working in CUDA as it is has been a giant moat for NVIDIA. Having a whole toolchain with a C++ dialect and a giant extant pile of code out there that looked familiar to people meant they've "won" the AI wars.<p>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.<p>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.<p>TLDR I don't think vendor lock on the software side is going to work out for them as a strategy.<p>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 <i>unlike</i> NVIDIA/CUDA.
The momentum behind rust seems absolutely unstoppable at the moment, in the light of this, the adoption of Rust into the Linux kernel, and the adoption of for formally verified software by Amazon and Microsoft.
not too long ago, commenters on HN hated Rust and would never use anything written in Rust. So, now that Rust is in Linux, they shouldn't be using Linux either.
Deservedly so.
Really exciting but it reads like Claude instead of what Nvidia posts have generally been like in the past. I don't need nor want my tech blogs to sound like a young adult novel.
NVIDIA is part of that shift
NVIDIA CUDA Rust closes that gap
I’ve had this happen to me several time over the past weeks and it’s gone from quaint to humorous to farcical to outright “is-the-world-gaslighting-me” insane.<p>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???<p>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.
Yeah definitely Claude. Lazy authors, if you're going to get AI to write for you please use Astra instead - it makes <i>way</i> less annoying prose than Claude.
How does this compare to vectorware? (<a href="https://www.vectorware.com/blog/" rel="nofollow">https://www.vectorware.com/blog/</a>)
VectorWare founder here. We are working with them and stoked they are investing more in Rust. I just gave a talk at RustConf about our different takes (<a href="https://rustconf2026.sched.com/event/2KNQj/making-gpus-feel-native-in-rust" rel="nofollow">https://rustconf2026.sched.com/event/2KNQj/making-gpus-feel-...</a>). The video isn't up yet but you should check it out when it is. The efforts are complementary.
Towards the end of the post, we (NVIDIA) mention that this work was done in collaboration with Vectorware and others in the Rust community. And we can't wait to build further with the community.
[dead]
Anyone know when Rust's std::autodiff will become stable? Assuming this Rust support expands to other GPU vendors, autograd will probably be the only reason to use Slang instead of Rust anymore.
Not a cuda programmer, but since they’re making a new API, why would they already make it inconsistent at start? :-/ I’m referring to the examples a,b,c vs z,x,y (different ordering of output elements)
Interesting direction from Nvidia. Anything that makes writing reliable GPU code less painful is definitely a good thing.
Does this weld Rust to CUDA? Can we use the Rust code to run on other archs?
Does this mean I can write shaders in Rust for use with WGPU or Vulkan?
For compute shaders, you can already do this with CubeCL: <a href="https://github.com/tracel-ai/cubecl" rel="nofollow">https://github.com/tracel-ai/cubecl</a><p>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)
WGPU/Vulkan don't work with PTX shaders by default, additional translation would be needed.<p>On a side note, Vulkan has extension to launch CUDA kernels: <a href="https://docs.vulkan.org/refpages/latest/refpages/source/VK_NV_cuda_kernel_launch.html" rel="nofollow">https://docs.vulkan.org/refpages/latest/refpages/source/VK_N...</a>
You have been able to for a while with rust-gpu <a href="https://github.com/Rust-GPU/rust-gpu" rel="nofollow">https://github.com/Rust-GPU/rust-gpu</a>.
The way I understood it, rust would become an option next to Vulkan, WGPU (and opengl etc?).<p>But only for compute tasks. So, practically an alternative language to write compute shaders in.
I read this the other day - definitely think it is the right direction Nvidia is taking.<p>Thank you NVIDIA - for once (not twice though - you've given us nothing but despair for Linux+GPU).
I'm looking forward to trying these when they stabilize! I currently use WGPU for graphics, and cudarc for CUDA.<p>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.<p>I haven't tried the tile API yet; looking forward to it.<p>The last time I checked, Cuda Oxide was Linux only, and required Async; these are why I haven't tried it yet.
cudarc been great for me, because it's easy to look up existing examples and references, and it maps 1-to-1 with what I see. I'm already having a tough time with CUDA itself, a dialect of it makes a tad harder to rely on previous work.<p>Seems more ergonomic in general though, both approaches they share, compared to cudarc, and less build infrastructure and fiddling with environments, which is great.
My understanding is not so deep regarding GPU programming or Rust... Does this mean anything regarding Nvidia GPUs and WebAssembly / WebGPU?
> The launch is checked rather than trusted.<p>Damn even Nvidia is putting out fully Claude-written articles.
That's actually a magnificent observation. This is not only an indication of a keen eye, but a trained brilliant mind as well.
> even Nvidia<p>Why "even Nvidia"?<p>They are fully behind using AI for basically everything.<p>What's next? "Damn, even McDonald's is putting out unhealthy food"
I think implication being organizations with 40,000+ employees and even more consultants and contractors plus a lot of budget are also using LLMs to draft public facing content instead of paying for content writers or even just proof readers .<p>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.
This does not imply that the organization is not paying for content writers or proof readers. It does suggest that they are not getting the value of paying for content writers or proof readers.
It does suggest that they are not <i>accurately measuring</i> the value of paying for content writers or proof readers.<p>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.
No. It suggests they don't mind littering slop into the information environment.
Of course, that is the whole point of using AI to replace workers.<p>Only devs think it isn't coming for them, it is empowering and nothing else will happen, no team reductions, nah how come.
Sure, but <i>even Anthropic</i> doesn't appear to use Claude for blog posts. (I don't think anyone should. The prose stinks.)
Their CEO also has the dubious distinction of claiming we've reached AGI more then once: <a href="https://www.theverge.com/ai-artificial-intelligence/985597/jensen-huang-says-nvidia-achieved-senseless-agi" rel="nofollow">https://www.theverge.com/ai-artificial-intelligence/985597/j...</a>
Is Jensen Huang still all-in on OpenClaw? That moment feels more like a flash in the pan.
I believe most of their marketing videos use fairly convincing text to speech too, not voice actors.
McDonald's food is not even that unhealthy. I just tried a Burger King burger the other day and it's terrible. I think it's like 2000 calories in a single burger or something.
2k cal would be around 250ml of oil. or 350grams of peanuts. So doing with bread, meat, and other stuff alike requires over 600g of food, an excellent value to energy.
> I think it's like 2000 calories in a single burger<p>that would be pretty cool, you can just get your entire day's calories from one burger
found the McShill. The King will hear of this!
[dead]
I get the impression that Nvidia employees don't care too much - I started seeing fully AI-written "documentation" on some of their smaller projects more than a year ago (i.e., before it was even slightly a good idea).
What are we for, I ask? What the hell are we now. Chatters to LLMs now? Is this our future? It really is starting to feel like it now.
Do you have the stomach to walk into a high school in the USA these days? Teachers use AI to generate assignments. Students feed the assignments to AI and submit the responses. Teachers feed the student submissions to an AI for grading.
As a high schooler going to a school with stricter rules on AI than most in my area, I can say that it's been going downhill ever since GPT 4. Teachers constantly use AI to create assignments(my French Teacher regularly handed us work with GPT 5.1 prose and emojis). Students are also rampantly using AI and bypassing school restrictions(We have a google account, making it easy to use Gemini if we just sign out), causing an inflation in GPAs and test scores. There's no easy solution to the problem, banning AI-tools only help somewhat as even typing into Google has AI web results, and students are quickly overcoming ways to restrict them. I have a friend that vibe coded an application that allowed his Mac Mini's desktop to be mirrored on his school chromebook, bypassing every restriction with sub 1-second latency. Of course, that opens the can of worms to whether schools should allow students to use AI...
> Of course, that opens the can of worms to whether schools should allow students to use AI...<p>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.<p>LLMs aren't calculators or even computers, their generated output is too flexible, generic and basically starts replacing thinking.<p>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.
I know many teachers who actually have respect for the profession, themselves, and the students. Thankfully that means they don't do this.<p>Whether this is a widespread macro trend is another issue, and would be terryfying.<p>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.
About half of the states in the USA require the ACT or SAT for high school graduation.<p>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.<p>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.<p>I'll leave it to others to argue about whether these exams are rigorous.
Remembering my teachers 20 years ago talking about staying in school grading until 8-9 PM, I wonder if these things are a symptom instead of a disease
Please tell me this is not true.
I have two kids in engineering programs at a state University. They are allowed to use AI for homework assignments, but the homework is no longer worth any credit. They have a lot more papers, quizzes, and tests in class that count for their entire grade.
This is true even at the undergraduate level unfortunately…
It's true of most work in many and soon most white collar jobs, too. Claude writes some dense useless thing, everyone else uses Claude to summarize and write a reply to the thing. The Claude-submitted PRs get automatically reviewed and commented on by a GitHub Claude review bot. The programmer asks Claude to check out Claude's review comments to Claude. Claude pushes a commit to the branch and writes a comment. The Claude review bot reviews the commit and leaves a comment. The human [...].<p>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.<p>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.
Dude I am in slop fucking hell right now. There is still room for a human touch, without which the agents will lever us harder and faster into a world of incomprehensible garbage.
I find it interesting that this was downvoted twice without explanation.
It is the number 1 thing I cannot stand with Claude slop. It's a sort of anthropomorphization of language. Every "thing" does, produces, feels, wants, asks, answers, etc....<p>- "Launch is checked"<p>- "Question is asked"<p>- "The implementation answers"<p>- "The model wants"<p>- "The results name"<p>- "The connection surfaces"<p>- "The prompt wires"<p>- "The feature rides the mechanism"<p>Every single fucking thing is alive, wants things, and does things.<p>It's terrible. Infuriating. I want to rip my eyeballs out reading this filth. All. The. Time. "The anger is real".
Create any page with a file uploader. They all look the same now. It's like the Twitter Bootstrap days of responsive design. You'll get an icon which looks like ones on (on the drop space) those sites which are like "you must wait 60 seconds for this file to download".<p>It's so horrible. The human element has been completely removed and replaced by..... mediocre.
All of the examples read like: "The dude abides", except in a grotesque/parody way.
I hadn't read the article and read this comment as though NVIDIA themselves were implying that this library was checked but not trusted by them since it was fully LLM generated.
not to worry, they have an 'AI generated summary' box too
Yeah. I think if the text is written for other machines, then by all means have an LLM generate it, but if it is intended for a human audience, have a human being write it.<p>We are still much better at writing in a way that doesn't waste other people's time.
Another of those AI is bad for articles, great for coding.<p>Plenty of us share the same opinion on doing reviews of AI generated code.
Thanks, saved me a few minutes
Even their writing skills are getting rusty.
Is that your honest load bearing assessment you’re going to flag?
it seems like that's the way the industry is headed
Claude, rewrite my graphics card in Rust. Make no mistakes.
I wonder how many parallels there are between CUDA's Tile abstraction and that of Metal.
So now every already written kernel can be re-written in Rust and have competitive performance to the cpp version?<p>If so, that's really big.<p>And to add the Next natural strp - custom codegen for simulating gpu compute and memory without Nvidia gpu.
Worth mentioning that Nvidia open sourced CUDA Tile IR ~8 months ago. And yes the code is open source too. <a href="https://news.ycombinator.com/item?id=46330732">https://news.ycombinator.com/item?id=46330732</a>
In this age of LLM written everything which has softly killed my motivation for learning Rust somewhat, this has revived my interest if not only for the fact the LLMs haven't yet been trained on this yet!
I've found sorta the opposite - in any area, it can just do everything for you, or it can be an incredible teacher. I've been re-learning a lot of higher-level math and it has been an knowledgeable, infinitely patient, always-available tutor. Of course, I could just have it do just about any math I want for me, but that's not the point.<p>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.<p>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!
> I've found sorta the opposite - in any area, it can just do everything for you, or it can be an incredible teacher.<p>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.<p>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.<p>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.<p>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.<p>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.
LLM don't need to be trained in a library to use it well. It's just Rust which they know well.
I was learning Rust slowly when the LLM enabled coding became good enough. I switched from learning to full on building with Rust. I still learn high level concepts as needed but I will not be able to write Rust on my own at all.<p>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.<p>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.
And what prevent you exactly ?<p>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.<p>You get an awesome teacher (LLM) ready to answer all your questions about Rust.<p>And you still find excuses not to learn it ?<p>At some point, just realize you've been lazy to learn it and LLMs are just an excuse.
I think OP’s point is that the payoff in learning a new language has diminished in this AI era. You can call that lazy, I’d consider it smart to consider whether you could be doing other, better, things with your time.
Sad to break it to you, but...<p>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<p><a href="https://github.com/rdaum/eider/tree/main/backends/cuda-oxide" rel="nofollow">https://github.com/rdaum/eider/tree/main/backends/cuda-oxide</a><p>And mostly just DeepSeek 4.1 Flash, too. Not even a frontier model.<p>Sorry.
[dead]
yikes, I prefer python taichi similar to<p>@fast
def calc(x,y):pass
Will it then be possible to query TJunc hotspot temps on linux?
The recent circular moves that Nvidia is making is designed to wrap things around them, anything to keep the AI model party going.
what this article tells me is that no one at Nvidia actually cares about this project whatsoever. otherwise, they would have had a person actually write the announcement.
Been waiting for something like this. CUDA C++ is a pain; Rust's safety for kernel programming could be a game changer.
First of all, this is a pre-1.0 release that requires a nightly Rust compiler (if you choose the SIMT track with cuda-oxide) so that one is going to be unstable software.<p>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).<p>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 !! You're in the right path.
hmmm interesting
Do it in Go and I’m interested
Go is simply not feasible for CUDA work mainly because of the go runtime that manages GC, allocation, scheduling etc<p>GPU kernels want explicit memory control and as little go-runtime like overhead as possible
AI slop article, how can I trust on this?
Nvidia only? Typical.<p>This is more promising: <a href="https://github.com/Rust-GPU/rust-gpu/" rel="nofollow">https://github.com/Rust-GPU/rust-gpu/</a>
[dead]
[dead]
[dead]
[dead]
[dead]
The world is unsafe
Rust for GPU programming? My CUDA debugging sessions just got a whole lot less painful, hopefully.
Makes me sad that Go doesn't get love. I feel like Go is perfect for LLMs.
Don't think we're gonna see garbage collections anywhere near gpu for many reasons.
Go's type system is not at the same level as C++, Fortran, Python, Julia, Haskell, Java, to quote the languages with CUDA support from NVIDIA and their partners.
[dead]