LLVM has python, go, ocaml and c bindings all in the same repository https://github.com/llvm-mirror/llvm/tree/master/bindings (the c bindings live somewhere else)
In Libp2p – A modular network stackllvm-mirror
llvm
LLVM2013–2022
llvm-mirror / llvm · Archived
llvm
Project moved to: https://github.com/llvm/llvm-project
41Distinct people
49Mentions
1Explicit recommenders
4.6KGitHub stars
What to know before exploring
What it is
Project moved to: https://github.com/llvm/llvm-project
GitHub
Where it is used
The source check is incomplete. Verified examples will appear here.
What people are saying
I recommend the LLVM source code. I've worked a bit with it implementing toy compilers and using LLVM as a backend for generating x86/SPARC object code. Just compiling it is a…
palotasb used a recommendation phrase. One indexed comment matches. This is a phrase match, not a verdict.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 7:02:26 AM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year49 dated mentions
Observed mentions: 2013-08-09 06:19:32 UTC to 2022-10-16 10:06:36 UTC.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2013 | 2013-01-01 00:00:00 UTC | 2014-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 6 | 1 | 5 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 9 | 2 | 7 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 7 | 0 | 7 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 8 | 0 | 8 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 12 | 0 | 12 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 3 | 0 | 3 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 1 | 0 | 1 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
The LLVM Compiler Infrastructure
================================
This directory and its subdirectories contain source code for LLVM,
a toolkit for the construction of highly optimized compilers,
optimizers, and runtime environments.
LLVM is open source software. You may freely distribute it under the terms of
the license agreement found in LICENSE.txt.
Please see the documentation provided in docs/ for further
assistance with LLVM, and in particular docs/GettingStarted.rst for getting
started with LLVM and docs/README.txt for an overview of LLVM's
documentation setup.
If you are writing a package for LLVM, see docs/Packaging.rst for our
suggestions.
Read the full README on GitHubWhat Hacker News says
12 sourcesBut it is aided by tail-call optimization. Suppose you have a function as follows:
int foo(int x) {
if (test(x)) return C;
return evaluate(x) + foo(adjust(x));
}
I can turn that function into:
int foo(int x) {
int accum = C;
for ( ; !test(x); x = adjust(x)) {
accum += evaluate(x);
}
return accum;
}
In the case of fibonacci, that equates to:
int fib(int x) {
int accum = 1;
for (; x > 1; x -= 2) {
accum += fib(x - 1);
}
return accum;
}
We still turned the recursive call (or one of them, at least), into a while loop.
And this idiom is recognized by both gcc and llvm. In fact. llvm has a test that specifically makes sure fib is transformed as thus: https://github.com/llvm-mirror/llvm/blob/30fa583f8430bfc7935...
In Recursive fibonacci benchmark using top languages on GitHubThis is definitely wrong :)
Besides Richard, who is the code owner of the clang frontend , chandler is the #5 contributor to LLVM (see here https://github.com/llvm-mirror/llvm/graphs/contributors), and a quick trip to llvm-dev will tell you how much time he spends working on optimizations :)
FWIW: The GCC folks i pinged were similarly unenamored with the idea of trying to elide allocation all the time.
Personally, i've seen a bunch of these "required optimizations" over the years, and they rarely pan out without significant help.
(IE required tail call optimization usually requires special marking/calling convention change, etc).
Full disclosure: Chandler, Geoff, and Richard are in my org, and i am theoretically their boss's boss. I say theoretically because it's pretty meaningless - i'm not going to tell Richard how to do C++.
In C++ Core Coroutines Proposal [pdf]Yet it contains monsters like this one https://github.com/llvm-mirror/llvm/blob/master/lib/Target/X...
In Ask HN: What open source project, in your opinion, has the highest code quality?Another approach not mentioned: LLVM's StringSwitch [1]. Unfortunately it's not designed to be used independent of LLVM, so it has a dependency or two. Also note that it's a slightly different use case (can only return different values, is not used for flow control).
[1] https://github.com/llvm-mirror/llvm/blob/master/include/llvm...
In Cttrie – Compile-time trie-based string matching for C++The llvm compiler has it's optimization routines here:
https://github.com/llvm-mirror/llvm/tree/master/lib/Transfor...
You can play around with how it takes in llvm code to optimized llvm code by using the opt tool.
Here's a basic example.
$ cat test.c
#include <stdio.h>
int main() {
for (int i = 0; i < 3; i++) {
printf("hello world");
}
}
$ clang -c -S -emit-llvm test.c
$ cat test.ll
** too long replacing with gist**
https://gist.github.com/cwgreene/b6f33d40ad735a448ed15057d91fdbdc
$ opt -S -print-before-all -O2 test.ll
** too long, replacing with gist**
https://gist.github.com/cwgreene/99b3075dbfffae35a5745934ded217fb
** final result**
@.str = private unnamed_addr constant [12 x i8] c"hello world\00", align 1
; Function Attrs: nounwind uwtable
define i32 @main() #0 {
entry:
%call = ta
Read the rest
il call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0)) #2
%call.1 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0)) #2
%call.2 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0)) #2
ret i32 0
}
The command `opt -S -print-before-all -O2` can be manually modified to specify exactly which compiler passes you want to see. You can run `opt --help` to see a list of all compiler passes. (you can figure out what code performs by looking at the * * * IR Dump Before `MODULE NAME` * * * and finding the associated logic in the Lib directory)
In the case of llvm, the idea for them is they break the code into things called 'basic blocks' which, along with using Single Static Assignment, are more easily analyzed, transformed, and simplified.
I'm not an expert in this field, also currently in learning mode.
> You said you were working on another JIT - what was that?
A JIT for a custom 32-bit RISC soft-CPU (FPGA).
> Also, do you have any suggestions of another project/language to implement compiler for to gain some knowledge about writing optimizations, actual intepretation/compilation logic, etc?
You could write another C compiler. Or a JIT for some scripting language. Lua is about as simple as it gets when it comes to JITtable scripting languages. Of course amazing http://luajit.org/ already exists.
Existing CPUs and bytecode formats are also potentially good.
In particular, other people might actually want to use a small WebAssembly (https://webassembly.org/) AOT/JIT compiler. I know I would. :)
Some source code I've personally found educating on this topic:
1) Lots of easie
Read the rest
r stuff (ARM/x86 encoding, basic optimizations, etc.) can be found in JITting emulators, like Dolphin: (https://github.com/dolphin-emu/dolphin)
2) Web browser Javascript engines, like (https://github.com/v8/v8/tree/master/src). And of course LuaJIT.
3) Compiler codegen, like LLVM (https://github.com/llvm-mirror/llvm)
Thanks. Unless something is escaping me, that's an optimizer bug. I'm pretty sure the ABI allows you to do whatever you want with the sret pointer, including passing it to another function to chain return for free.
I guess you could say that RVO is more robust since it's implemented in the frontend and does not rely on finding the optimization after a fair amount of lowering.
Edit: I don't have time to debug this but at least for llvm, I think this optimization should trigger in the optimizer's memcpy elimination pass ( https://github.com/llvm-mirror/llvm/blob/0818e789cb58fbf6b5e... ).
However I don't see why clang could not simply apply the RVO logic to C code as well.
In One year of CIt is not, just take a look at the third party directory of chromium, where it tracks all its third party dependencies
https://github.com/chromium/chromium/tree/master/third_party
the main point of their build system gn (similar to bazel) is to have explicit and distribution independent control of all dependencies (typically tied to specific versions).
LLVM basically has no system dependencies as well, instead it implements a lot of platform abstractions within the repository (https://github.com/llvm-mirror/llvm/tree/master/lib/Support), the remaining dependencies are mostly build dependencies such as python 2.7 and cmake.
Same story for Cryengine (https://github.com/CRYTEK/CRYENGINE/tree/release/Code/Libs) and Unreal Engine (https://github.com/EpicGames/UnrealEngine/tree/release/Engin...).
Linux distributions simply duplicate a lot of w
Read the rest
ork because they are based on a flawed and outdated distribution model, outdated because the main argument for shared libraries disappears with > 1 TB commodity hard drives. The approach taken by the projects above is also the only way to do cross platform development, simply because both Windows, macOS and Consoles don't have the concept of an operating system package manager. (If you are using homebrew for development on mac, you will run into a lot of trouble sooner or later).
Could you explain what part of their code of conduct ( https://github.com/llvm-mirror/llvm/blob/master/docs/CodeOfC... ) is racist or sexist?
In “There is, unfortunately, no such thing as a truly neutral stance on inclusion”The llvm commit on GitHub (which shows whole diff at once):
https://github.com/llvm-mirror/llvm/commit/8b2a3e8b203a332bb...
In Compiler bug? Linker bug? Windows Kernel bug