evcxr/evcxr
Evcxr
EvalXR is an interactive Rust compiler that compiles code into dynamically loaded libraries for iterative evaluation without restarting the process. It serves as a Rust Jupyter kernel, a notebook runtime, and a REPL environment, all with state retention across evaluations.
The project provides a stateful Rust evaluation engine that runs code snippets in isolated sandboxes while keeping functions and variables alive between executions. It supports cell-based execution, compiling Rust code into a shared library and loading it into the same process to preserve state, with an error-aware compilation pipeline that captures and reports compiler errors and panics as structured messages. Communication with Jupyter frontends follows the standard ZMQ-based message protocol for interactive notebook execution.
The tool enables interactive Rust programming, literate programming with Rust, and Rust code prototyping. It supports Jupyter cell execution with rich output, persistent interactive sessions for debugging, variable and type inspection, and shareable Rust notebooks.
Features
- Interactive Rust Compilers - Compiles Rust code into dynamically loaded libraries for iterative evaluation without restarting the process.
- Notebook Cell Execution - Provides a cell-based execution model that preserves Rust state across evaluations in Jupyter notebooks.
- Stateful Snippet Runners - Runs isolated Rust code snippets while keeping functions and variables available across multiple executions.
- Rust - Evaluates Rust code one line at a time in a REPL or notebook, showing results immediately.
- Jupyter Kernel Protocols - Communicates with Jupyter frontends using the standard ZMQ-based message protocol for interactive notebook execution.
- Jupyter Language Kernels - Serves as a Jupyter kernel that executes Rust code in notebook cells for literate programming.
- Rust - Integrates Rust as a kernel inside Jupyter notebooks for literate, interactive programming with visual outputs.
- Rust REPLs - Provides a read-eval-print loop for Rust that compiles and runs code line by line with state retention.
- Stateful Rust Evaluators - Evaluates Rust code snippets interactively while preserving state across evaluations for REPL and notebook environments.
- Rust Jupyter Cell Execution - Runs Rust code cells inside a Jupyter notebook, producing rich output integrated with the notebook workflow.
- Literate Programming Notebooks - Creates executable Rust notebooks that combine code, documentation, and results for reproducible analysis.
- Dynamic Library Loading - Loads compiled Rust code as shared libraries at runtime to preserve state across evaluations.
- Evaluation State Retention - Retains user-defined variables and functions across multiple evaluations by reusing the same compiled library context.
- Runtime Code Compilation - Compiles Rust code into shared libraries at runtime for iterative evaluation without restarting the process.
- Notebook Runtimes - Runs Rust code in notebook cells with inline output and state retention for literate programming.
- Interactive Rust Environments - Enables running Rust code line by line in a REPL or Jupyter notebook with immediate results.
- Sandboxed Code Evaluators - Compiles and runs Rust code in a sandboxed environment that preserves state between evaluations.
- Code Evaluation Sessions - Evaluates Rust expressions and statements in a persistent session for iterative experimentation and debugging.
- Structured Compilation Diagnostics - Captures Rust compiler errors and panics as structured messages for immediate feedback during interactive sessions.
- Variable Inspection Tools - Displays current values and types of variables in the evaluation context for exploration and debugging.
- Shareable Notebooks - Provides shareable Rust notebooks that others can run without any local setup.
- Rust Snippet Prototyping - Provides an isolated environment for quickly testing Rust snippets with persistent variables across evaluations.
