https://github.com/bytecodealliance/wasmtime-dotnet
.NET embedding of Wasmtime https://bytecodealliance.github.io/wasmtime-dotnet/
https://github.com/bytecodealliance/wasmtime-dotnet
dotnet wasmtime webassembly
Last synced: 7 months ago
JSON representation
.NET embedding of Wasmtime https://bytecodealliance.github.io/wasmtime-dotnet/
- Host: GitHub
- URL: https://github.com/bytecodealliance/wasmtime-dotnet
- Owner: bytecodealliance
- License: apache-2.0
- Created: 2020-04-01T18:21:12.000Z (almost 6 years ago)
- Default Branch: main
- Last Pushed: 2025-07-11T02:49:58.000Z (7 months ago)
- Last Synced: 2025-07-12T00:44:56.652Z (7 months ago)
- Topics: dotnet, wasmtime, webassembly
- Language: C#
- Homepage:
- Size: 1.94 MB
- Stars: 451
- Watchers: 20
- Forks: 53
- Open Issues: 27
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
## Installation
You can add a package reference with the [.NET SDK](https://dotnet.microsoft.com/):
```text
$ dotnet add package wasmtime
```
## Introduction
For this introduction, we'll be using a simple WebAssembly module that imports
a `hello` function and exports a `run` function:
```wat
(module
(func $hello (import "" "hello"))
(func (export "run") (call $hello))
)
```
To use this module from .NET, create a new console project:
```
$ mkdir wasmintro
$ cd wasmintro
$ dotnet new console
```
Next, add a reference to the [Wasmtime package](https://www.nuget.org/packages/Wasmtime):
```
$ dotnet add package wasmtime
```
Replace the contents of `Program.cs` with the following code:
```c#
using System;
using Wasmtime;
using var engine = new Engine();
using var module = Module.FromText(
engine,
"hello",
"(module (func $hello (import \"\" \"hello\")) (func (export \"run\") (call $hello)))"
);
using var linker = new Linker(engine);
using var store = new Store(engine);
linker.Define(
"",
"hello",
Function.FromCallback(store, () => Console.WriteLine("Hello from C#!"))
);
var instance = linker.Instantiate(store, module);
var run = instance.GetAction("run")!;
run();
```
An `Engine` is created and then a WebAssembly module is loaded from a string in
WebAssembly text format.
A `Linker` defines a function called `hello` that simply prints a hello message.
The module is instantiated and the instance's `run` export is invoked.
To run the application, simply use `dotnet`:
```
$ dotnet run
```
This should print `Hello from C#!`.
## Contributing
### Building
Use `dotnet` to build the repository:
```
$ dotnet build Wasmtime.sln
```
This will download the latest development snapshot of Wasmtime for your
platform.
### Testing
Use `dotnet` to run the unit tests:
```
$ dotnet test Wasmtime.sln
```
### Creating the NuGet package
Use `dotnet` to create a NuGet package:
```
$ cd src
$ dotnet pack Wasmtime.sln -c Release /p:Packing=true
```
This will create a `.nupkg` file in `src/bin/Release`.
By default, local builds will use a `-dev` suffix for the package to
differentiate between official packages and development packages.
### Updating Wasmtime for a release
To update the Wasmtime library used for a new release, change `WasmtimeVersion`
in `Directory.Build.props`:
```xml
$VERSION
```
### Publishing the Wasmtime .NET NuGet package
GitHub actions is used to automatically publish a package to NuGet when a tag
is pushed to the repository.
To publish a new release, create a release in GitHub and add the relevant
release notes.
Use a tag of the format `v$VERSION` where `$VERSION` matches the Wasmtime
version used by the .NET package; ensure the tagged commit matches the last
commit to make for the release.
When the release is published on GitHub, an action should automatically start
to build and publish the package to NuGet.
