Llvm-project Alternatives

llvm-project reviews and mentions

• Xcode and Gradle: Two worlds, one infrastructure
  8 projects | dev.to | 7 Oct 2026

  Then Apple introduced compilation caching in Xcode 26 using LLVM's Content Addressable Storage (CAS). For Gradle developers unfamiliar with this: CAS is a storage model where artifacts are stored and retrieved by the hash of their content, similar in spirit to how Git stores objects. The granularity is impressive, sub-function level, meaning Xcode can skip recompiling individual compilation units if their inputs have not changed. But the remote cache interface is a gRPC protocol with no public SDK. The only way to provide a remote cache is to run a service that speaks this protocol and tell Xcode where to find it via a Unix socket.

• AMD's random number generator can't generate a 0?
  7 projects | news.ycombinator.com | 22 Sep 2026

  Use of uninitialized memory is UB, and incidentally, the type of UB that the C standard is not working to define, but is relying on sanitizers to find in source programs, since it is considered always a bug.

  This entire thread has a lot of "no security issues have ever been found in my code, and I test a lot. Therefore no bugs will ever exist in my code and we're all safe." To see you doing this in an explicitly security-conscious setting is distressing.

  If anything, I see assertions like this and juxtaposed with blatant, willful misunderstanding of how C and C compilers work and it does the opposite of inspiring confidence.

  Look at CVE-2009-1897; this is the classic example of how C compilers are happy to try to optimize code in the face of UB and lead to worse problems.

  > If the above code has any but one of the above 16 outputs

  I don't think you understand how insane optimizations in the face of UB can be. Just go look at this issue:

  https://github.com/llvm/llvm-project/issues/174844?utm_sourc...

• AMD Advancing AI 2026: Software, Hardware & Framework, Unified
  6 projects | dev.to | 23 Jul 2026

  Chris Lattner created LLVM, the compiler infrastructure a huge amount of modern software quietly runs on. So when he talks, I try to keep up. His point wasn't only about software. It was about how the hardware we run works with the applications we write, and why you can't reason about one without the other.

• Everyone Should Know SIMD
  12 projects | news.ycombinator.com | 22 Jul 2026

  The loop dependency on a poly isn't all that hard to unroll, and most correctly rounded implementations are polys. You're often paying only a couple cycles' worth of stalls.

  We can see this in action. LLVM implements sin() with a correctly rounded double poly [0]. We can ignore range reduction and throw the core into compiler explorer to be autovectorized [1]. uiCA estimates a theoretical latency for the inner loop of 15 cycles, and the code achieves 18.

  I suspect most custom implementations would do worse than this.

  [0] https://github.com/llvm/llvm-project/blob/165c472d65cd62eb33...

  [1] https://godbolt.org/z/rGGq8aG38

• Claude Is Not a Compiler
  1 project | news.ycombinator.com | 22 Jul 2026

  >In a production-grade compiler like LLVM they are rare enough that it compiles giant projects like Linux and Chromium without detectable issues.

  https://github.com/llvm/llvm-project/issues

• NoiseLang: Where N = 5 is a Dirac delta
  4 projects | news.ycombinator.com | 8 Jul 2026

  there's been some forward movement on doing this via an appropriate intrinsic in LLVM

  https://github.com/llvm/llvm-project/pull/166702

  note that this isn't the only "trick" needed for constant-time programming though. Indexing an array with a secret index needs its own trick, for example.

  I agree that trying to trick the compiler is very ugly. A well-known applied cryptographer has a paper from last year saying that not only is it ugly, but it doesn't work particularly well, and if anything the trendline of the various "tricks" is that they get less effective over time.

  https://eprint.iacr.org/2025/435

• I Hate Compilers
  4 projects | news.ycombinator.com | 17 Jun 2026

  I filed the bug: https://github.com/llvm/llvm-project/issues/204883

• Memory safety CVEs differ between Rust and C/C++
  6 projects | news.ycombinator.com | 15 Jun 2026

  https://github.com/llvm/llvm-project/issues/45725

  Are you familiar with pointer provenance ? This gets very deep, very fast, so if you don't know and don't want to know I can't help you, but if you do want to know try maybe: https://www.ralfj.de/blog/2018/07/24/pointers-and-bytes.html

  So e.g. if we make a pointer to thing A, which we then destroy, and then for a pointer to thing B, and then we compare these pointers, even if the address which will be the only bits making up this pointer in hardware was identical, a language could choose to say these pointers are not the same (Rust says they compare equal but that's up to Rust). LLVM is equipped to do this optimisation. So far, not a bug, though perhaps not what you expected...

  However everybody is pretty sure that we don't want provenance for other value types. It's troublesome for pointers but we're used to it and it unlocks important optimisations, but for every other value type it's just extra trouble. So Rust's provenance model says only pointers have provenance, and proposals for C and C++ likewise. If we ask for the address from a pointer, making it into just an integer, it should not longer have provenance.

  But, LLVM doesn't really track whether a value "is" pointer or not per se, so it ends up applying that "they're not equal" optimisation to the integers we've made from pointers, even though the integers are definitely equal and we're about to do a subtraction to prove it. Bang.

• Ask HN: Who wants to be hired? (June 2026)
  19 projects | news.ycombinator.com | 1 Jun 2026

  - A merged C++ patch to the LLVM compiler: https://github.com/llvm/llvm-project/pull/70845

  For more context, please visit my website: https://oestoleary.com. I'm excited to connect!

• Theseus: Translating Win32 to WASM
  8 projects | news.ycombinator.com | 27 May 2026

  If you’re poking around WASM consider falling down the Component Model rabbit hole:

  https://github.com/WebAssembly/component-model/blob/main/des...

  Threading is actively being worked on right now (to be released in 0.3.x, soon), and some changes just made their way into LLVM as well:

  https://github.com/llvm/llvm-project/pull/175800

• A note from our sponsor - AppSignal
  www.appsignal.com | 13 Oct 2026

  Stop vibe-debugging. Every exception, every backtrace, grouped so you see patterns, not noise. Learn more →