awesome-repositories.com
Blog
awesome-repositories.com

Découvrez les meilleurs dépôts open-source grâce à notre recherche par IA.

ExplorerRecherches sélectionnéesAlternatives open sourceLogiciels auto-hébergésBlogPlan du site
ProjetÀ proposNotre méthodologiePresseServeur MCP
Mentions légalesConfidentialitéConditions d'utilisation
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
root-project avatar

root-project/cling

0
View on GitHub↗
4,147 stars·314 forks·C++·5 vues

Cling

Cling est un interpréteur C++ interactif et une boucle de lecture-évaluation-impression (REPL) qui permet l'exécution de code C++ en temps réel. Il fournit un environnement interactif où les instructions peuvent être évaluées immédiatement, contournant les cycles de compilation et de liaison manuels généralement requis pour le langage.

Le système fonctionne comme un noyau Jupyter C++, permettant le développement et la visualisation basés sur des cellules au sein d'interfaces de notebook. Il prend également en charge le chargement et l'exécution de fichiers sources externes au sein d'une session active.

L'environnement inclut des capacités de débogage et de profilage juste-à-temps en émettant des symboles de débogage pour le code compilé. Cela permet à la logique interprétée d'être analysée en utilisant des outils de profilage et de débogage système standards.

Features

  • Read-Eval-Print Loops - Provides a read-eval-print loop for the immediate evaluation and execution of C++ statements.
  • Interactive C/C++ Prototyping - Supports interactive development and logic testing through a read-eval-print loop without full recompilation.
  • Language-Specific REPLs - Provides a language-specific REPL for executing C++ statements interactively without full compilation cycles.
  • Jupyter Language Kernels - Implements a dedicated C++ kernel that enables cell-based development and visualization within Jupyter notebooks.
  • Jupyter Notebook Integrations - Integrates C++ execution into notebook environments via a dedicated kernel for cell-based development.
  • Notebook Environment Integrations - Provides a communication layer that maps Jupyter notebook cell requests to an interactive C++ execution environment.
  • Rapid Prototyping Environments - Enables rapid prototyping of C++ code snippets and libraries by bypassing manual compilation and linking cycles.
  • C++ REPLs - Implements a read-eval-print loop for prototyping and testing C++ logic through immediate statement evaluation.
  • JIT-Compiled Bytecode Execution - Translates C++ source into LLVM intermediate representation and compiles it to machine code at runtime.
  • C++ Interpreters - Provides an interactive environment for executing C++ code in real time without manual compilation and linking.
  • Incremental Compilation - Implements mechanisms to process small code snippets while maintaining a persistent global state across execution cells.
  • Just-In-Time Compilation - Leverages LLVM infrastructure to generate optimized native machine code on the fly from an interactive input stream.
  • Execution-to-Source Mappers - Emits debug symbols during runtime compilation to map machine code back to the original source.
  • JIT Debugging & Profiling - Emits debug symbols for just-in-time compiled code to enable analysis via standard system profiling and debugging tools.
  • Interpreter Debuggers and Profilers - Allows analysis of interpreted C++ logic using standard profiling tools via emitted debug symbols.
  • Compiler-Integrated AST Parsing - Uses a Clang-based frontend to parse C++ source into abstract syntax trees for interactive execution.

Historique des stars

Graphique de l'historique des stars pour root-project/clingGraphique de l'historique des stars pour root-project/cling

Recherche par IA

Explorez plus de dépôts awesome

Décrivez vos besoins en langage naturel — l'IA classe des milliers de projets open source sélectionnés par pertinence.

Start searching with AI

Alternatives open source à Cling

Projets open source similaires, classés selon le nombre de fonctionnalités partagées avec Cling.
  • luajit/luajitAvatar de LuaJIT

    LuaJIT/LuaJIT

    5,592Voir sur GitHub↗

    LuaJIT is a high-performance Lua language implementation and just-in-time compiler. It functions as an embedded scripting engine and dynamic binary translator that converts portable bytecode into native machine code during execution. The project focuses on high-performance scripting by translating bytecode into architecture-specific instructions to achieve execution speeds close to compiled C code. It utilizes a lightweight runtime environment designed for minimal memory overhead. The system supports binary data processing via bitwise operations and enables asynchronous task management throu

    C
    Voir sur GitHub↗5,592
  • sbt/sbtAvatar de sbt

    sbt/sbt

    4,929Voir sur GitHub↗

    Sbt is a JVM build tool and dependency management system designed for Scala and Java. It functions as a multi-project build orchestrator that manages the compilation of source code, resolves external libraries from remote repositories, and packages binaries for distribution. The project is distinguished by its interactive build system, which provides a read-eval-print loop for real-time state inspection and task execution. It utilizes a dependency-graph based execution model to process tasks and maintains a type-safe key-value store for dynamic build configuration. Its capabilities cover JVM

    Scala
    Voir sur GitHub↗4,929
  • gopherdata/gophernotesAvatar de gopherdata

    gopherdata/gophernotes

    3,965Voir sur GitHub↗

    Gophernotes is a backend implementation of the Jupyter kernel protocol and an interactive runtime that enables the execution of Go language code within notebook environments. It serves as a Go language execution engine, allowing users to integrate Go into polyglot notebooks such as Jupyter and nteract. The project supports the creation of documents that combine executable source code with rich media. It maps internal data types to various formats, including HTML, JSON, LaTeX, PDF, and images, to provide visual representations of execution results. The system covers a range of capabilities in

    Goartificial-intelligencedata-sciencego
    Voir sur GitHub↗3,965
  • wasm3/wasm3Avatar de wasm3

    wasm3/wasm3

    7,936Voir sur GitHub↗

    Wasm3 is a WebAssembly interpreter designed for embedded runtime integration. It enables the execution of portable binary logic on microcontrollers and resource-constrained hardware, providing support for modules that utilize the WebAssembly System Interface to interact with system resources. The runtime employs register-based bytecode interpretation and direct-threaded dispatch to map virtual registers to physical CPU registers. It includes a host-call interface to map imports to C functions and utilizes static module validation to ensure bytecode follows specification rules before execution

    C
    Voir sur GitHub↗7,936
Voir les 30 alternatives à Cling→

Questions fréquentes

Que fait root-project/cling ?

Cling est un interpréteur C++ interactif et une boucle de lecture-évaluation-impression (REPL) qui permet l'exécution de code C++ en temps réel. Il fournit un environnement interactif où les instructions peuvent être évaluées immédiatement, contournant les cycles de compilation et de liaison manuels généralement requis pour le langage.

Quelles sont les fonctionnalités principales de root-project/cling ?

Les fonctionnalités principales de root-project/cling sont : Read-Eval-Print Loops, Interactive C/C++ Prototyping, Language-Specific REPLs, Jupyter Language Kernels, Jupyter Notebook Integrations, Notebook Environment Integrations, Rapid Prototyping Environments, C++ REPLs.

Quelles sont les alternatives open-source à root-project/cling ?

Les alternatives open-source à root-project/cling incluent : luajit/luajit — LuaJIT is a high-performance Lua language implementation and just-in-time compiler. It functions as an embedded… sbt/sbt — Sbt is a JVM build tool and dependency management system designed for Scala and Java. It functions as a multi-project… gopherdata/gophernotes — Gophernotes is a backend implementation of the Jupyter kernel protocol and an interactive runtime that enables the… wasm3/wasm3 — Wasm3 is a WebAssembly interpreter designed for embedded runtime integration. It enables the execution of portable… bobthecow/psysh — PsySH is an interactive read-eval-print loop and shell environment for PHP. It functions as a runtime debugger and… ipython/ipython — IPython is an interactive computing environment and programmable extension of the Python read-eval-print loop. It…