evcxr/evcxr

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.

Star history