frontpage.
newsnewestaskshowjobs

Open Source @Github

fp.

Old Bitly links are being hijacked

https://ransomnews.com/burger-king-tweet-bitly-link-hijack-2026/
177•hspeiser•4h ago•95 comments

Coles hit by a cybersecurity incident

https://www.colesgroup.com.au/updates/
31•sagunsh•1h ago•9 comments

Preserving 30 years of Salon journalism

https://blog.archive.org/2026/11/12/preserving-30-years-of-salon-journalism/
75•CharlesW•3h ago•20 comments

Protomaps: Self-hosting map tiles has gotten cheap and easy

https://bruceroettgers.eu/blog/protomaps/
177•bcye•6h ago•43 comments

Tor Project Issues Rapid-Response DoS-Defense Fix Amid Sustained DDoS Attack

https://forum.torproject.org/t/security-release-0-4-9-17/22454
26•aillia•2h ago•6 comments

A short explainer on how El Niño works [video]

https://www.youtube.com/watch?v=7_JF3etiAv8
178•nharada•7h ago•81 comments

Crows make decisions faster than we can

https://www.nytimes.com/2026/11/15/science/birdbrain-crows-birds-research-decision.html
174•gumby•8h ago•126 comments

Mini.nvim Is Now on Tangled

https://tangled.org/nvim-mini.org/mini.nvim
36•nerdypepper•2h ago•10 comments

The MacBook Pro's OLED PWM problem

https://macanorak.com/the-macbook-pros-oled-pwm-problem-when-a-better-display-becomes-worse-to-use/
428•MacAnorak•13h ago•238 comments

Handwriting, as a Font

https://ductus.sorenblank.com
134•coinfused•6h ago•34 comments

WebGL Flight Simulator with seed generated terrain

https://baron.by.dai.studio/
94•ranger_danger•6h ago•11 comments

Universal XSS in uBlock Origin from website-driven element picker

https://iter.ca/post/ubo-uxss/
5•zaik•17m ago•0 comments

What's Next for Nvidia?

https://steveblank.com/2026/11/15/whats-next-for-nvidia/
71•zdw•2h ago•66 comments

Do we still have to denormalize? Have your schema and search it too

https://www.paradedb.com/blog/joins
8•philippemnoel•2d ago•1 comments

Claude Code and Codex reverse engineered my 1994 Jeep's ECU over a $3 Arduino [video]

https://www.youtube.com/watch?v=WPj3aQ-xxpI
344•envoked•3d ago•173 comments

DefCon: Breaking into Amazon Lockers by Any Means Necessary

https://www.youtube.com/watch?v=ZVmRe8OVZtE
9•brudgers•4h ago•3 comments

Things That Turbo Pascal Is Smaller Than (2011)

https://prog21.dadgum.com/116.html
206•ksec•12h ago•109 comments

"Who is Hiring?" postings stuck near 12-year lows as AI reaches half of all jobs

https://www.hntrends.com/2026/november.html
40•myth_drannon•50m ago•8 comments

Microsoft 365 outage leads to chlorine gas poisoning of 15 hotel guests

https://www1.wdr.de/nrw/rheinland/rhein-erft-kreis/technischer-defekt-chlor-phantasialand-100.html
405•DeepLogin•7h ago•186 comments

1900s How do you Wash a Kimono?

https://www.oldphotosjapan.com/photos/877/laundry-washing-clothes-meiji-19th-century-vintage-albu...
20•Matrixik•2d ago•3 comments

Show HN: The Last Complication, a Zachtronics-style watchmaking puzzle game

https://lastcomplication.com/
49•tdeangelis•3h ago•6 comments

Eclipse Mosquitto – An open source MQTT broker

https://github.com/eclipse-mosquitto/mosquitto
67•gregsadetsky•7h ago•28 comments

Understanding Positional Embeddings in Modern LLMs

https://magazine.sebastianraschka.com/p/understanding-positional-embeddings
206•vismit2000•14h ago•27 comments

Emacs Is My Browser

https://joshblais.com/blog/emacs-as-my-browser/
183•nyc111•11h ago•99 comments

A quest to create the perfect whiskey glass

https://www.nytimes.com/2026/11/13/dining/drinks/kurt-josef-zalto-whiskey-glass.html
50•Kaibeezy•2d ago•49 comments

Aspidistra: A British wartime radio transmitter used for MitM attacks

https://en.wikipedia.org/wiki/Aspidistra_(transmitter)
30•BoxOfRain•3d ago•4 comments

Clice v1.0 Released: Welcome to Modern C++

https://ykiko.me/en/articles/2105384023094834022/
106•molenzwiebel•8h ago•68 comments

Vulcan rocket fails during return-to-flight launch, 40 Amazon satellites lost

https://www.space.com/space-exploration/launches-spacecraft/ula-vulcan-centaur-return-to-flight-a...
120•jonbaer•5h ago•67 comments

Notes on Mathematics for Engineers (1959) [pdf]

https://websites.umich.edu/~ners311/CourseLibrary/MathNotes.pdf
74•the-mitr•4d ago•20 comments

Eval Awareness vs. Eval Paranoia

https://www.lesswrong.com/posts/mepsi7JNKYejq9wry/eval-awareness-vs-eval-paranoia
50•ezrasu•3d ago•21 comments
Open in hackernews

CubeCL: GPU Kernels in Rust for CUDA, ROCm, and WGPU

https://github.com/tracel-ai/cubecl
210•ashvardanian•1y ago

Comments

zekrioca•1y ago
Very interesting project! I am wondering how it compare against OpenCL, which I think adopts the same fundamental idea (write once, run everywhere)? Is it about CUbeCL's internal optimization for Rust that happens at compile time?
nathanielsimard•1y ago
A lot of things happen at compile time, but you can execute arbitrary code in your kernel that executes at compile time, similar to generics, but with more flexibility. It's very natural to branch on a comptime config to select an algorithm.
fc417fc802•1y ago
This appears to be single source which would make it similar to SYCL.

Given that it can target WGPU I'm really wondering why OpenCL isn't included as a backend. One of my biggest complaints about GPGPU stuff is that so many of the solutions are GPU only, and often only target the vendor compute APIs (CUDA, ROCm) which have much narrower ecosystem support (versus an older core vulkan profile for example).

It's desirable to be able to target CPU for compatibility, debugging, and also because it can be nice to have a single solution for parallelizing all your data heavy work. The latter reduces mental overhead and permits more code reuse.

zekrioca•1y ago
Makes sense. And indeed, having OpenCL as a backend would be a very interesting extension.
ttoinou•1y ago
Who would use the OpenCL backend rather than the others targets provided ?
wingertge•1y ago
There's infrastructure in the SPIR-V compiler to be able to target both OpenCL and Vulkan, but we don't currently use it because OpenCL would require a new runtime, while Vulkan can simply use the existing wgpu runtime and pass raw SPIR-V shaders.

One thing I've never investigated is how performance OpenCL actually is for CPU. Do you happen to have any resources comparing it to a more native CPU implementation?

fc417fc802•1y ago
Sorry my interest there is debugging and I'm not immediately coming across good benchmarks. PoCL [0] seems to have added a TBB backend [1] so I'd expect it to be reasonable (otherwise why bother) but I haven't tested it.

It isn't really related to your question but I think the FluidX3D benchmarks [2] illustrate that OpenCL is at least viable across a wide variety of hardware.

As far as targeting CPUs in a release build it's not a particular backend that's important to me. The issue is at the source code level. Having single source is nice but you're still stuck with these two very different approaches. It means that the code is still clearly segmented and thus retargeting any given task (at least nontrivial ones) involves rewriting it to at least some extent.

Contrast that with a model like OpenMP where the difference between CPU and GPU is marking the relevant segment for offload. Granted that you'll often need to change algorithms when switching to achieve reasonable performance but it's still a really nice quality of life feature not to have to juggle more paradigms and libraries.

[0] https://github.com/pocl/pocl

[1] https://portablecl.org/docs/html/drivers.html

[2] https://github.com/ProjectPhysX/FluidX3D

LegNeato•1y ago
See also this overview for how it compares to other projects in the Rust and GPU ecosystem: https://rust-gpu.github.io/ecosystem/
qskousen•1y ago
Surprised this doesn't mention candle: https://github.com/huggingface/candle
the__alchemist•1y ago
I don't think that fits; that's a ML framework. The others in the link are general GPU frameworks.
the__alchemist•1y ago
Love it. I've been using cudarc lately; would love to try this since it looks like it can share data structures between host and device (?). I infer that this is a higher-level abstraction.
adastra22•1y ago
Where is the Metal love…
syl20bnr•1y ago
It also compiles directly to MSL, it is just missing from the post title.
adastra22•1y ago
No it compiles indirectly through wgpu, which means it doesn’t have access to any Metal extensions not exposed by the wgpu interface.
syl20bnr•1y ago
I am the coder of the MSL dialect for the CubeCL CPP compiler. Since 0.5 release it directly compiles to MSL and support simdgroup matrix functions for instance. It does use wgpu for the runtime but without naga as we added msl pass through to wgpu just for this.
adastra22•1y ago
You should update the README.
syl20bnr•1y ago
You are right we just released Burn and updated its readme, we were not thinking that CubeCL would be the one that could be featured. ^_^
grovesNL•
gitroom•1y ago
Gotta say, the constant dance between all these GPU frameworks kinda wears me out sometimes - always chasing that better build, you know?
nathanielsimard•1y ago
The need to build CubeCL came from the Burn deep learning framework (https://github.com/tracel-ai/burn), where we want to easily build algorithms like in CUDA with a real programming language, while also being able to integrate those algorithms inside a compiler at runtime to fuse dynamic graphs.

Since we don't want to rewrite everything multiple times, it also has to be multi-platform and optimal, so the feature set must be per-device, not per-language. I'm not aware of a tool that does that, especially in Rust (which Burn is written in).

fc417fc802•1y ago
> I'm not aware of a tool that does that

Jax? But then you're stuck in python. SYCL?

But yeah not for Rust. This project is filling a prominent hole IMO.

rowanG077•1y ago
Futhark immediately came to mind. It's designed to be able to be trivially integrated into a package.
kookamamie•1y ago
This reminds me of Halide (https://halide-lang.org/).

In Halide, the concept was great, yet the problems in kernel development were moved to the side of "scheduling", i.e. determining tiling/vectorization/parallellization for the kernel runs.

rfoo•1y ago
I'd recommend having a "gemm with a twist" [0] example in the README.md instead of having an element-wise example. It's pretty hard to evaluate how helpful this is for AI otherwise.

[0] For example, gemm but the lhs is in fp8 e4m3 and rhs is in bf16 and we want fp32 accumulation, output to bf16 after applying GELU.

ashvardanian•1y ago
Agreed! I was looking through the summation example < https://github.com/tracel-ai/cubecl/blob/main/examples/sum_t...> and it seems like the primary focus is on the more traditional pre-2018 GPU programming without explicit warp-level operations, asynchrony, atomics, barriers, or countless tensor-core operations.

The project feels very nice and it would be great to have more notes in the README on the excluded functionality to better scope its applicability in more advanced GPGPU scenarios.

0x7cfe•1y ago
CubeCL is the computation backend for Burn (https://burn.dev/) - ML framework done by the same team which does all the tensor magic like autodiff, op fusion and dynamic graphs.
nathanielsimard•1y ago
We support warp operations, barriers for Cuda, atomics for most backends, tensor cores instructions as well. It's just not well documented on the readme!
ashvardanian•
bionhoward•1y ago
Praying to the kernel gods for some Rust FP8 training
DarkmSparks•1y ago
wow, what's the downsides to this? It feels like it could be one of the biggest leaps in programming in a long time, does it keep rusts safety aspects? How does it compare with say openCL?
nathanielsimard•1y ago
We have safe and unsafe version for launching kernels where we can ensure that a kernel won't corrupt data elsewhere (and therefore won't create memory error or segfaults). But within a kernel ressources are mutable and shared between GPU cores, since that's how GPUs work.
1y ago
wgpu has some options to access backend-specific types and shader passthrough (i.e., you provide your own shader for a backend directly).

Generally wgpu is open to supporting any Metal extensions you need. There's usually an analogous extension in one of the other backends (e.g., Vulkan, DX12) anyway.

moffkalast•1y ago
From the moment I understood the weakness of my flesh, it disgusted me. I craved the strength and certainty of steel. I aspired to the purity of the Blessed Machine.
Almondsetat•1y ago
Why would anyone love something born out of pure spite for industry standards?
pjmlp•1y ago
For the same reason CUDA and ROCm are supported.
miohtama•1y ago
Apple is known to be not that great contributor to open source, unlike Nvidia, AMD, Intel.
pjmlp•1y ago
You should check Linus opinion on those.

Also, to whom do you have to thank LLVM exists in first place, and has not fizzled out as yet another university compiler research project?

m-schuetz•1y ago
To be fair, the industry standards all suck except for CUDA.
1y ago
Amazing! Would love to try them! If possible, would also ask for a table translating between CubeCL and CUDA terminology. It seems like CUDA Warps are called Planes in CubeCL, and it’s probably not the only difference.
nathanielsimard•1y ago
One of the main author here, the readme isn't really well up-to-date. We have our own gemm implementation based on CubeCL. It's still moving a lot, but we support tensor cores, use warp operations (Plane Operations in CubeCL), we even added TMA instructions for CUDA.
wingertge•1y ago
We don't yet support newer types like fp8 and fp4, that's actually my next project. I'm the only contributor with the hardware to actually use the new types, so it's a bit bottlenecked on a single person right now. But yes, the example is rather simplistic, should probably work on that some time once I'm done updating the feature set to Blackwell.
lostmsu•1y ago
Isn't there a CPU-based "emulator" in Nvidia dev tools?
wingertge•1y ago
From what I can tell it's not accurate enough to catch a lot of errors in the real world. Maybe an illegal instruction, but not a race condition from a missing sync or a warp divergence on a uniform instruction or other potential issues like that.