README.md

.NET Interactive Documentation

Our documentation is still a work in progress. There are a number of topics listed under Features below that don't have outgoing links yet, but we've included them to give a better sense of the current feature set. Please open an issue if you'd like to know more about one of the topics we haven't gotten around to documenting yet.

What is .NET Interactive?

.NET Interactive is an engine that can run multiple languages and share variables between them. Languages currently supported include:

• C#
• F#
• PowerShell
• JavaScript
• SQL
• KQL (Kusto Query Language)
• HTML*
• Mermaid*

*Variable sharing not available

What can .NET Interactive be used for?

As a powerful and versatile engine, .NET Interactive can be used to create and power a number of tools and experiences such as:

• Polyglot Notebooks
• REPLs
• Embeddable script enginges

Polyglot Notebooks

Since .NET Interactive is capable of behaving as a kernel for notebooks, it enables a polyglot (multi-language) notebook experience.

In Polyglot Notebooks, you can use multiple languages and share variables between them. No more installing different Jupyter kernels, using wrapper libraries, or different tools to get the best language server support for the language of your choice. Always use the best language for the job and seamlessly transition between different states of your workflow, all within one notebook.

Visual Studio Code

For the best experience when working with multi-language notebooks, we recommend installing the Polyglot Notebooks Extension.

Jupyter and nteract

There are several ways to get started using .NET Interactive with Jupyter, including Jupyter Notebook, JupyterLab, and nteract.

• Try sample .NET notebooks online using Binder.
• Create and run .NET notebooks on your machine.
• Share .NET notebooks online using Binder.

REPLs

.NET Interactive can be used as the execution engine for REPLs. For an example using a CLI, see .NET REPL. In addition, .NET REPL can actually be used to set up automation for your Polyglot Notebooks.

Acknowledgements

The multi-language experience of .NET Interactive is truly a collaborative effort amongst other groups at Microsoft. We'd like to thank the following teams for contributing their time and expertise to helping light up functionality for other languages.

• PowerShell Team: PowerShell
• Azure Data/SQL Team: SQL, KQL

Other

Small factor devices

We support running on devices like Raspberry Pi and pi-top [4]. You can find instructions here.

Telemetry

Telemetry is collected when .NET Interactive is started. Once .NET Interactive is running, we collect hashed versions of packages imported into the notebook and the languages used to run individual cells. We do not collect any additional code or clear text from cells. The telemetry is anonymous and reports only the values for a specific subset of the verbs in the .NET Interactive CLI. Those verbs are:

• dotnet interactive jupyter
• dotnet interactive jupyter install
• dotnet interactive http
• dotnet interactive stdio

How to opt out

The .NET Interactive telemetry feature is enabled by default. To opt out of the telemetry feature, set the DOTNET_INTERACTIVE_CLI_TELEMETRY_OPTOUT environment variable to 1 or true.

Disclosure

The .NET Interactive tool displays text similar to the following when you first run one of the .NET Interactive CLI commands (for example, dotnet interactive jupyter install). Text may vary slightly depending on the version of the tool you're running. This "first run" experience is how Microsoft notifies you about data collection.

Telemetry
---------
The .NET Core tools collect usage data in order to help us improve your experience.The data is anonymous and doesn't include command-line arguments. The data is collected by Microsoft and shared with the community. You can opt-out of telemetry by setting the DOTNET_INTERACTIVE_CLI_TELEMETRY_OPTOUT environment variable to '1' or 'true' using your favorite shell.

To disable this message and the .NET Core welcome message, set the DOTNET_INTERACTIVE_CLI_TELEMETRY_OPTOUT environment variable to true. Note that this variable has no effect on telemetry opt out.

Features

• Support for multiple languages
• Display output (C# | F# | PowerShell)
• Create plots with with Xplot
• "Magic commands"
• Import NuGet packages
• Language-specific features
  • C#
    • The C# scripting dialect
    • PocketView
  • F#
    • F# Interactive (FSI)
  • HTML and JavaScript
  • PowerShell
    • PowerShell profile support
    • PowerShell host support
    • AzShell support
• Getting input from the user
• Multi-language notebooks
  • Switching between languages
    • Per-cell
    • Within a single cell
  • .NET variable sharing
  • Accessing kernel variables from the client with JavaScript

Technical details

• Architecture
• How Jupyter kernel installation works

Visualization

• XPlot
• Visualization with JavaScript libraries

.NET Interactive API Guides

• Using the .NET Interactive command-line interface

.NET API Guide (TODO)

• Commands and events
• Formatter APIs
  • Working with MIME types
• PocketView
• Magic commands
• Kernel APIs
  • Variable sharing
• JSON API for Standard I/O and HTTP modes (TODO)

JavaScript API Guide (TODO)

• Accessing kernel data from client-side JavaScript
• Loading modules / RequireJS support
• Accessing static resources
• Sending kernel commands and consuming kernel events

Extending .NET Interactive

• Overview
• Building your own extension
  • Adding magic commands
• Publishing your extension using NuGet