#jupyter #menu #repl #kernel #select #evcxr

app evcxr_jupyter

A Jupyter Kernel for Rust

34 releases

0.14.2 Jan 2, 2023
0.14.1 Oct 29, 2022
0.14.0 Sep 22, 2022
0.13.0 Jul 11, 2022
0.2.0 Oct 8, 2018
Download history 275/week @ 2022-10-11 236/week @ 2022-10-18 313/week @ 2022-10-25 302/week @ 2022-11-01 234/week @ 2022-11-08 244/week @ 2022-11-15 227/week @ 2022-11-22 206/week @ 2022-11-29 264/week @ 2022-12-06 208/week @ 2022-12-13 249/week @ 2022-12-20 288/week @ 2022-12-27 370/week @ 2023-01-03 326/week @ 2023-01-10 253/week @ 2023-01-17 391/week @ 2023-01-24

1,440 downloads per month

Apache-2.0

300KB
6K SLoC

Evcxr Jupyter Kernel

Binder

Latest Version

A Jupyter Kernel for the Rust programming language.

Installation

If you don't already have Rust installed, follow these instructions.

You can either download a pre-built binary from the Releases page, extract it from the archive and put it somewhere on your path, or build from source by running:

cargo install evcxr_jupyter

Whether using a prebuilt binary or one you built yourself, you'll need to run the following command in order to register the kernel with Jupyter.

evcxr_jupyter --install

If your operating system is an older version, or has a different libc than what the pre-built binaries were compiled with, then you'll need to build from source using the command above.

To actually use evcxr_jupyter, you'll need Jupyter notbook to be installed.

  • Debian or Ubuntu Linux: sudo apt install jupyter-notebook
  • Mac: You might be able to brew install jupyter
  • Windows, or if the above options don't work for you, see https://jupyter.org/install

You'll also need the source for the Rust standard library installed. If you already use rust-analyzer, you'll likely have this installed. To install this using rustup, run:

rustup component add rust-src

Running

To start Jupyter Notebook, run:

jupyter notebook

Once started, it should open a page in your web browser. Look for the "New" menu on the right and from it, select "Rust".

Usage information

Evcxr is both a REPL and a Jupyter kernel. See Evcxr common usage for information that is common to both.

Custom output

The last expression in a cell gets printed. By default, we'll use the debug formatter to emit plain text. If you'd like, you can provide a function to show your type (or someone else's type) as HTML (or an image). To do this, the type needs to implement a method called evcxr_display which should then print one or more mime-typed blocks to stdout. Each block starts with a line containing EVCXR_BEGIN_CONTENT followed by the mime type, then a newline, the content then ends with a line containing EVCXR_END_CONTENT.

For example, the following shows how you might provide a custom display function for a type Matrix. You can copy this code into a Jupyter notebook cell to try it out.

use std::fmt::Debug;
pub struct Matrix<T> {pub values: Vec<T>, pub row_size: usize}
impl<T: Debug> Matrix<T> {
    pub fn evcxr_display(&self) {
        let mut html = String::new();
        html.push_str("<table>");
        for r in 0..(self.values.len() / self.row_size) {
            html.push_str("<tr>");
            for c in 0..self.row_size {
                html.push_str("<td>");
                html.push_str(&format!("{:?}", self.values[r * self.row_size + c]));
                html.push_str("</td>");
            }
            html.push_str("</tr>");
        }
        html.push_str("</table>");
        println!("EVCXR_BEGIN_CONTENT text/html\n{}\nEVCXR_END_CONTENT", html);
    }
}
let m = Matrix {values: vec![1,2,3,4,5,6,7,8,9], row_size: 3};
m

It's probably a good idea to either print the whole block at once, or to lock stdout then print the block. This should ensure that nothing else prints to stdout at the same time (at least no other Rust code).

If the content is binary (e.g. mime type "image/png") then it should be base64 encoded.

Prompting for input

:dep evcxr_input
let name = evcxr_input::get_string("Name?");
let password = evcxr_input::get_password("Password?");

Installing from git head

If there's a bugfix in git that you'd like to try out, you can install directly from git with the command:

cargo install --force --git https://github.com/google/evcxr.git evcxr_jupyter

3rd party integrations

There are several Rust crates that provide Evcxr integration:

  • Petgraph
    • Graphs (the kind with nodes and edges)
  • Plotly
    • Lots of different kinds of charts
  • Plotters
    • Charts
  • Showata
    • Displays images, vectors, matrices (nalgebra and ndarray)

3rd party resources

Limitations

  • Don't ask Jupyter to "interrupt kernel", it won't work. Rust threads can't be interrupted.

Uninstall

evcxr_jupyter --uninstall
cargo uninstall evcxr_jupyter

Dependencies

~38MB
~781K SLoC