SUsuzumer·Oct 24, 2024
Cern uses cling now (https://github.com/root-project/cling)
In Pretty.croot-project
cling
C++2017–2024
root-project / cling
cling
The cling C++ interpreter
20Distinct people
20Mentions
0Explicit recommenders
4.2KGitHub stars
What to know before exploring
What it is
The cling C++ interpreter
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
No recommendation phrase was found in the indexed comments.
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 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 1:49:46 PM 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 year20 dated mentions
Observed mentions: 2017-08-10 20:24:24 UTC to 2024-10-24 12:50:58 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 |
|---|---|---|---|---|---|
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 3 | 0 | 3 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 6 | 0 | 6 |
| 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 | 0 | 0 | 0 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 4 | 1 | 3 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 3 | 1 | 2 |
What Hacker News says
20 sourcesFolks interested in this should absolutely look at the open source Cling project, which uses Clang/LLVM to JIT compile C++ in-process. https://github.com/root-project/cling
I'm using Cling, as part of jank, a native Clojure dialect on LLVM, with C++ interop. This allows me to have truly interactive, dynamic programming, while still reaching into native code. jank source compiles to C++, which is then JIT compiled by Cling. In recent benchmarks, it can be several times faster than Clojure JVM. https://jank-lang.org/
In C and C++ Hot-Reload/Live CodingCling: Interactive C++ Interpreter
3 points · Open discussionSimilar to Cling[1] from ROOT.
[1] https://github.com/root-project/cling
In Interactive GCC (igcc) is a read-eval-print loop (REPL) for C/C++This is a cute implementation. Though for anyone wondering, an actually interactive C++ REPL does exist: https://clang.llvm.org/docs/ClangRepl.html
See also: https://github.com/root-project/cling
In TermiC: Terminal C, Interactive C/C++ REPL shell created with bash> The repl driven workflow is amazing and the lisp images are rock solid and highly performant.
do people not realize that basically everything vm/interpreted language has a repl these days?
https://www.digitalocean.com/community/tutorials/java-repl-j...
https://github.com/waf/CSharpRepl
https://pub.dev/packages/interactive
not to mention ruby, python, php, lua
hell even c++ has a janky repl https://github.com/root-project/cling
edit: i get downvoted by the lisp crowd every time i bring up that the repl isn't a differentiating feature anymore :shrug:
In It's 2023, so of course I'm learning Common LispOh, there's apparently a repl for clang/c++: "cling"
http://code-ballads.net/read-eval-print-loop-repl-in-c/
https://code-ballads.net/generated-notebooks/cpp/repl_cling/...
https://github.com/root-project/cling
https://blog.jupyter.org/interactive-workflows-for-c-with-ju...
There's been some discussion on hn before, but I couldn't find anything particularly recent (or interesting tbh).
Then there is of course rr, as seen recently on hn:
"Instant replay: Debugging C and C++ programs with rr"
https://news.ycombinator.com/item?id=27034588
And I also came across "inspector"- which unfortunately appears to be abandoned?
"Inspector - A drop-anywhere C++ Repl"
https://news.ycombinator.com/item?id=16360738
In I quit my job to focus on SerenityOS full timeIt has been done several times, at least.
http://www.hanno.jp/gotom/Cint.html
https://github.com/root-project/cling
https://www.softintegration.com
You can argue whether some of those are strictly interpreters, versus just a REPL hooked up to a compiler (as in the case of Cling). But they do exist.
In Wisp: A light Lisp written in C++Well, there's this [0] Scheme->C compiler, so if you were to port Cling [1] (C++ interpreter) to it, then you'd have achieved that goal pretty well. It'd be a large project, but practical to achieve.
[0] https://github.com/sph-mn/sph-sc
[1] https://github.com/root-project/cling
In Wisp: A light Lisp written in C++Does Cling C++ interpreter do what you want? https://github.com/root-project/cling
In What I wish someone had told me about tensor computation librariesIs cling not good enough? (It disables most optimizations)
https://github.com/root-project/cling
In 30% Faster Rust Build Times using Cranelift instead of the LLVMNeat. It wraps GCC.
See also Cling, an interactive C++ interpreter.
https://github.com/root-project/cling
In Show HN: Runc – Compile and run C in one commandI have to admit I totally latched onto the point you made about fast development time.
The interpreter+compiler approach is something I've been pining for for a little while now. I've only just begun to punch holes in my obsessive tendency to only use interpreted languages (because I hate compile waits that much), and to me having the fast-iteration times of interpreters, and _also_ -O3 when it's needed, would be the best of all the worlds; IMHO JITs are a necessary hack for dynamic/untyped(/interpreted) languages, and there are serious real-world gains to be had from having the plumbing get done that lets people jump from interpretation, over JITs, straight to optimized AOT-compiled code.
Would be quite the project though, to port a fundamentally-compiled ecosystem like D to use an interpreter. I wonder how long a realistic timeframe to
Read the rest
"minimally practically usable" would be.
Thinking about it, Cling (https://root.cern.ch/cling, https://github.com/root-project/cling, LGPL 2.1) wires Clang's C AST into LLVM's built-in JIT (IIUC) to get a C/C++ interpreter. D has LDC, so there is already integration of the UI/NCSAOSL and understanding of how to leverage LLVM. Perhaps a workable direction (with probably a lot of domain-specific knowledge already worked out and potentially available from ROOT) could be a Cling-like s/Clang/LDC/->LLVM ?
Another thought: using an approach like the above, it might be possible to add pragmas that specify whether functions should be AOTed or JITed, and how much JIT optimization should be done. I also wonder if the LLVM JIT can be told/forced to "precompile this specific function" (effectively AOTing just that function), within the JIT hot-code-replacement framework; if this were possible you could even hot-reload running code (with per-function/per-file/etc customizable optimization levels). IMHO it may be interesting to make this functionality available, and let the community/ecosystem work through the messiness of solving things like the struct-versioning problem. Clear communication would be important to rationalize and clarify the deliberateness of such a decision, of course, and that the language [design] hadn't gone completely nuts :) due to the number of segfaults/developer burnout/etc it would probably introduce.
Showing the 15 most recent of 20 sources. Enable JavaScript to search and browse every indexed mention.