gopherdata/gophernotes
Gophernotes
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 including the execution of system shell commands, management of notebook execution contexts, and the linking of third-party packages across different operating systems.
Features
- Notebook Code Execution - Provides the ability to execute Go source code within notebook cells and return immediate results to the user.
- Jupyter Language Kernels - Acts as a Go language execution engine that allows users to run Go code and shell commands within Jupyter notebooks.
- Jupyter Notebook Integrations - Integrates the Go language into Jupyter and nteract environments to create documents with live code.
- Internal Messaging Protocols - Implements a socket-based request-response protocol using ZeroMQ for communication between the kernel and notebook frontend.
- JSON Message Exchanges - Uses a structured JSON schema to exchange execution requests and rich media results between the kernel and frontend.
- Ephemeral Source Generation - Writes cell contents to temporary Go files on disk for compilation and execution by the native toolchain.
- Interactive Runtimes - Provides an environment for executing Go source code in cells to produce live outputs and rich media visualizations.
- Notebook Kernels - Implements the Jupyter kernel protocol to process and return Go language execution results.
- Source-to-Binary Compilation Toolchains - Integrates with the installed Go compiler and linker to transform source code into executable binaries at runtime.
- Polyglot Notebooks - Enables a polyglot workflow by adding Go as a compatible execution kernel within a single notebook interface.
- Interactive Data Exploration - Allows processing data in notebook cells and rendering results as HTML or JSON for easier analysis.
- Output Format Rendering - Renders analysis results and code output into multiple formats including HTML and JSON for display in notebook cells.
- Literate Programming Tools - Combines executable Go source code with formatted text and images to create technical documentation and tutorials.
- MIME Type Mappings - Maps internal Go data types to supported media formats like LaTeX, PDF, and HTML for rich rendering.
- Interactive Development - Supports a development workflow where Go code is written and tested in small chunks with immediate feedback.
- Image Rendering - Converts image data into standard formats with metadata for visual display within a notebook cell.
- MIME Type Renderers - Maps Go data structures to specific MIME types like HTML or JSON for specialized rendering in the notebook UI.
- Interactive Execution - Jupyter Notebook kernel for Go.
