[QUESTION]: Can .NET interactive be embedded in a Web Application?

[rrekapalli]

Hi there,

Does this library be embedded in a web application developed in ASP.NET/Angular/React?

Thanks

[jonsequitur]

Yes. There are a number of packages on NuGet and you can see an embedding example in this sample.

[colombod]

We are working on exposing the tools to configure your aspnet host with .NET Interactive in PR #802

[rrekapalli]

Thank you!

[PawelStadnicki]

@colombod aspnet host PR mentioned above seems to be merged now however there is no sample yet/blog/tutorial about it?
Hosting dotnet-interactive on custom webpage is highly anticipated IMHO

[colombod]

@colombod aspnet host PR mentioned above seems to be merged now however there is no sample yet/blog/tutorial about it?
Hosting dotnet-interactive on custom webpage is highly anticipated IMHO

Consuming .NET Interactive from a web page is not hard to begin but crafting a good experience takes time. We do not have yet documentation or tutorial for it but you can take a peak at a simple demo I have built here.

That is not official sample and would love your feedback, maybe you could help building a simple demo?

[PawelStadnicki]

Thanks, I will try it.
Will it be supported to use other kernels too ? I guess that GitHub Codespaces has the same functionality as VS Code.
Wonder how much effort will be required to host on custom page same functionality as VS Code or GitHub Codespaces ( I assume that VS Code & Github Codespaces uses internal "notebook" support that must be adjusted for own purposes).

I can also guess that definitely there will be some blazor-flavour at some point.
I also know that MS internally uses some "trydotnetjs" that can also be public at some point
but grasping it all is hard without the full roadmap.

[colombod]

Thanks, I will try it.
Will it be supported to use other kernels too ? I guess that GitHub Codespaces has the same functionality as VS Code.
Wonder how much effort will be required to host on custom page same functionality as VS Code or GitHub Codespaces ( I assume that VS Code & Github Codespaces uses internal "notebook" support that must be adjusted for own purposes).

I can also guess that definitely there will be some blazor-flavour at some point.
I also know that MS internally uses some "trydotnetjs" that can also be public at some point
but grasping it all is hard without the full roadmap.

You can already use any other kernel for .NET Interactive. That app has the same engine as the VSCode, Jupiter, and Jupiterlab integration. You can access the sharp, fsharp, powershell and js languages. To have same functionality as the code spaces you might want to look at the nteract SDK to create your frontend. Wiring up Monaco editor could be complex but I would not be surprised if the nteract ecosystem already has a Monaco integration

[GeorgeS2019]

Is it feasible to make .NET interactive hostable within Blazor Webassembly so we could make .NET interactive sharing e.g. TorchSharp data science tutorials/examples available through Github Pages

[jonsequitur]

A WASM-based kernel is feasible and is something we plan to investigate. Try .NET uses WASM today, so we'll look into building one or more new subkernels that can produce and run WASM along similar lines.

[AlexHedley]

Is this linked in anyway to trydotnetjs?

• Project Description - Simple to Embed: JavaScript Support try#95
• https://github.com/dotnet/try/blob/main/DotNetTry.md
• https://github.com/dotnet/try-samples#basics

[jonsequitur]

The Try .NET project has been merged into .NET Interactive but an updated version hasn't been released yet. https://github.com/dotnet/interactive/blob/main/docs/FAQ.md#how-is-net-interactive-related-to-try-net

[evertoncolling]

@jonsequitur any news on a WASM-based kernel (#800 (comment))? I've been using Pyodide kernel in Jupyterlite for a while now and it works great. It would be nice to be able to run C# or F# code entirely on the browser.

[AlexHedley]

One option I was working on was using Blazor dotnet-interactive-blazor-wasm to host the backend and call to that, after seeing a video from Steve S https://www.youtube.com/watch?v=gKX-cdqnb8I, but it’s very much WIP.

[jonsequitur]

Not totally sure why we need an external service, though - doesn't Mono (used for Blazor) have an interpreter? Should be good enough for some small snippets?

Compilation happens in the cloud so that the entire compilation toolchain and resources such as XML documentation files don't need to be downloaded to the browser. This provides a very significant performance improvement over trying to do compilation in the browser. Once compiled, an assembly containing the user's code is executed in the browser using Blazor WASM.

You can see a breakdown of the call flows here: https://github.com/dotnet/interactive/tree/main/src/Microsoft.DotNet.Interactive.CSharpProject#try-net--microsoft-learn-flow

Requiring a backend service is a huge deal, because it requires a sufficiently sandboxed environment to execute raw user input.

A sandbox isn't needed because the user's code is executed within their own browser.

[haslingerm]

A sandbox isn't needed because the user's code is executed within their own browser.

As long as the users can't add arbitrary source generators/analyzers or do other shenanigans. But I guess in this scenario the environment can be well controlled, so that shouldn't be an issue, true.

I run a service where students can enter code and have it checked—not only if it compiles, but also if a set of unit tests passes. So, I do have user code execution on the server and needed a sandbox for that, which is why my thoughts drifted in that direction.

[AlexHedley]

I built BlazorInteractive in WASM to run code snippets, a bit like .NET Fiddle but it meant I could host it on GitHub Pages and not worry about a server, but it was a lot of work and still needs a load of features. If I could just use Interactive instead I’d get all the power for free.

[hawkerm]

I feel like this is an assembly loading thing where .NET Interactive is assuming it can load assemblies from disk. In Alex's case he already loaded the assemblies from the Blazor framework output behind the scenes to use CodeAnalysis.CSharp. For general .NET and WASM you can load them manually as well as part of the output, this is what's done in this Uno demo here: https://github.com/jeromelaban/uno.skiasharpfiddle.

Seems like it'd be a matter of providing an option for loading assemblies from a general location vs. having .NET interactive take on that responsibility and assume it knows where they are?

[PawelStadnicki]

I was working on sth like this: hosting Interactive on the Blazor app that runs F# code on a client browser, using my own mini-editor based on Monaco.
All the code was created with F# (even JS with fable compiler), and Blazor is only to serve the wasm purpose.
Currently, it works ok on the server-blazor but the client mode (wasm) fails because of the F# Kernel limitations (I believe the same will be for C#).

F# kernel uses standard F# script engine (fsi) which is heavily Input-Output related (console logging, files etc), a lot of stuff that will not work on wasm or must be tailored/marked for that purpose. I asked the F# team to make the FSI lighter without any unnecessary computation tied to the environment.

I expect it will not be a part of the .NET 9, though, but when I have time I will try to do my experiments

Worth mentioning is also the fact, that with .NET 9 (tentative) wasm is going to support real multithreading :)

[AlexHedley]

I’ve got an F# WIP branch on mine but it’s a bit more involved, as you say.

[jonsequitur]

The C# Script engine is quite different from FSI and can potentially run under WASM but in both cases, there will be significant performance problems due to the number of files that are needed in the browser, especially for language services.

[PawelStadnicki]

I somehow missed the info that multithreading in Blazor-wasm is officially postponed till .NET 10 ...
I don't see the point for my use cases to run the code on the client that cannot be multi-threaded, taking into account another valid performance point from @jonsequitur.

So much work is needed in both Wasm and F# within at least a 1.5-year horizon

[GeorgeS2019]

Any update, embedded in Blazor in 2025?