# root-project/cling

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/root-project-cling).**

4,147 stars · 314 forks · C++ · NOASSERTION

## Links

- GitHub: https://github.com/root-project/cling
- awesome-repositories: https://awesome-repositories.com/repository/root-project-cling.md

## Topics

`c-plus-plus` `clang` `interpreter` `jupyter` `llvm`

## Description

Cling is an interactive C++ interpreter and read-eval-print loop that allows for the execution of C++ code in real time. It provides an interactive environment where statements can be evaluated immediately, bypassing the manual compilation and linking cycles typically required for the language.

The system functions as a Jupyter C++ kernel, enabling cell-based development and visualization within notebook interfaces. It also supports the loading and execution of external source files within an active session.

The environment includes capabilities for just-in-time debugging and profiling by emitting debug symbols for compiled code. This allows interpreted logic to be analyzed using standard system profiling and debugging tools.

## Tags

### Development Tools & Productivity

- [Read-Eval-Print Loops](https://awesome-repositories.com/f/development-tools-productivity/read-eval-print-loops.md) — Provides a read-eval-print loop for the immediate evaluation and execution of C++ statements.
- [Interactive C/C++ Prototyping](https://awesome-repositories.com/f/development-tools-productivity/developer-utilities-libraries/workflow-productivity-enhancers/developer-productivity-utilities/developer-experience/interactive-debugging-testing/interactive-c-c-prototyping.md) — Supports interactive development and logic testing through a read-eval-print loop without full recompilation.
- [Language-Specific REPLs](https://awesome-repositories.com/f/development-tools-productivity/interactive-repls/language-specific-repls.md) — Provides a language-specific REPL for executing C++ statements interactively without full compilation cycles. ([source](https://github.com/root-project/cling#readme))
- [Jupyter Language Kernels](https://awesome-repositories.com/f/development-tools-productivity/jupyter-language-kernels.md) — Implements a dedicated C++ kernel that enables cell-based development and visualization within Jupyter notebooks.
- [Jupyter Notebook Integrations](https://awesome-repositories.com/f/development-tools-productivity/jupyter-notebook-integrations.md) — Integrates C++ execution into notebook environments via a dedicated kernel for cell-based development. ([source](https://github.com/root-project/cling/blob/master/tools/Jupyter))
- [Notebook Environment Integrations](https://awesome-repositories.com/f/development-tools-productivity/notebook-environment-integrations.md) — Provides a communication layer that maps Jupyter notebook cell requests to an interactive C++ execution environment.
- [Rapid Prototyping Environments](https://awesome-repositories.com/f/development-tools-productivity/rapid-prototyping-environments.md) — Enables rapid prototyping of C++ code snippets and libraries by bypassing manual compilation and linking cycles.
- [C++ REPLs](https://awesome-repositories.com/f/development-tools-productivity/read-eval-print-loops/rust-repls/c-repls.md) — Implements a read-eval-print loop for prototyping and testing C++ logic through immediate statement evaluation.
- [Execution-to-Source Mappers](https://awesome-repositories.com/f/development-tools-productivity/source-map-generators/execution-to-source-mappers.md) — Emits debug symbols during runtime compilation to map machine code back to the original source.

### Programming Languages & Runtimes

- [JIT-Compiled Bytecode Execution](https://awesome-repositories.com/f/programming-languages-runtimes/bytecode-virtual-machines/jit-compiled-bytecode-execution.md) — Translates C++ source into LLVM intermediate representation and compiles it to machine code at runtime.
- [C++ Interpreters](https://awesome-repositories.com/f/programming-languages-runtimes/c-interpreters/c-interpreters.md) — Provides an interactive environment for executing C++ code in real time without manual compilation and linking.
- [Incremental Compilation](https://awesome-repositories.com/f/programming-languages-runtimes/incremental-compilation.md) — Implements mechanisms to process small code snippets while maintaining a persistent global state across execution cells.
- [Just-In-Time Compilation](https://awesome-repositories.com/f/programming-languages-runtimes/just-in-time-compilation.md) — Leverages LLVM infrastructure to generate optimized native machine code on the fly from an interactive input stream.
- [JIT Debugging & Profiling](https://awesome-repositories.com/f/programming-languages-runtimes/jit-debugging-profiling.md) — Emits debug symbols for just-in-time compiled code to enable analysis via standard system profiling and debugging tools. ([source](https://github.com/root-project/cling#readme))
- [Interpreter Debuggers and Profilers](https://awesome-repositories.com/f/programming-languages-runtimes/language-interpreters/interpreted-code-debuggers/interpreter-debuggers-and-profilers.md) — Allows analysis of interpreted C++ logic using standard profiling tools via emitted debug symbols.

### Software Engineering & Architecture

- [Compiler-Integrated AST Parsing](https://awesome-repositories.com/f/software-engineering-architecture/abstract-syntax-tree-parsing/compiler-integrated-ast-parsing.md) — Uses a Clang-based frontend to parse C++ source into abstract syntax trees for interactive execution.