Edge.js allows you to run Node.js and .NET code in one process on Windows, macOS, and Linux

You can call .NET functions from Node.js and Node.js functions from .NET.
Edge.js takes care of marshaling data between CLR and V8. Edge.js also reconciles threading models of single-threaded V8 and multi-threaded CLR.
Edge.js ensures correct lifetime of objects on V8 and CLR heaps.
The CLR code can be pre-compiled or specified as C#, F#, Python (IronPython), or PowerShell source: Edge.js can compile CLR scripts at runtime.
Edge can be extended to support other CLR languages or DSLs.

Edge.js provides an asynchronous, in-process mechanism for interoperability between Node.js and .NET. You can use this mechanism to:

• script Node.js from a .NET application on Windows using .NET Framework
• script C# from a Node.js application on Windows, macOS, and Linux using .NET Framework/.NET Core
• use CLR multi-threading from Node.js for CPU intensive work more...
• write native extensions to Node.js in C# instead of C/C++
• integrate existing .NET components into Node.js applications
• access MS SQL from Node.js using ADO.NET
• script F# from Node.js
• script Powershel from Node.js
• script Python (IronPython) from Node.js

Read more about the background and motivations of the project here.

• Support for new versions of Node.Js.
• Support for .NET Core 3.1 - 9.x on Windows/Linux/macOS.
• Fixes AccessViolationException when running Node.js code from C# PR #573.
• Fixes StackOverflowException PR #566 that occurs when underlying C# code throws complex exception.
• Fixes issues #469, #713
• Other PRs: PR #725, PR #640
• Multiple bug fixes and improvements to the original code.

For use with Electron electron-edge-js

VS Code uses Electron shell, to write extensions for it using Edge.js use electron-edge-js

Sample app that shows how to work with .NET Core using inline code and compiled C# libraries.
https://github.com/agracio/edge-js-quick-start

• Windows: Visual C++ Redistributable

• Windows supports 4 latest LTS or candidate LTS releases (even numbered).
• Windows supports up to 1 "Current" (odd numbered) release and drops it when superseeded by new LTS candidate.
• macOS comes precompiled with same releases as Windows. When using Node.js version that is not pre-compiled edge-js binaries will be compiled during npm install using node-gyp.
• Linux will always compile edge-js binaries during npm install using node-gyp.

Other Linux architectures might work but have not been tested.

Mono is no longer actively supported. Existing code will remain In Edge.Js but focus will be on .NET Core.

* Edge.js does not have a flag to force it to run in Mono environment on Windows, it would only be possible to run if you have Windows without .NET Framework present.
* On Linux there is a known bug that will throw exception when executing C# code under certain conditions. Use one of the following options.

1. Set LD_PRELOAD env variable before running Edge.js with Mono

EXPORT LD_PRELOAD="libmono-2.0.so libmonosgen-2.0.so libstdc++.so.6"

2. Set LD_PRELOAD in your Node.js app entry point using Javascript

Object.assign(process.env, {
    // Work around Mono problem: undefined symbol: mono_add_internal_call_with_flags
    LD_PRELOAD: 'libmono-2.0.so libmonosgen-2.0.so libstdc++.so.6',
});

Source: mono/mono#17079 (comment)

Edge.js uses this code in test setup:

When packaging your application using Webpack make sure that edge-js is specified as external module.

module.exports = {
  target: 'node',
  externals: {
    'edge-js': 'commonjs2 edge-js',
    'edge-cs': 'commonjs2 edge-cs',
  },
  node: {
    __dirname: true,
    __filename: true,
  },
}

next.config.js

const nextConfig = {
  serverExternalPackages: ['edge-js'],
}
 
module.exports = nextConfig

next.config.ts

const nextConfig: NextConfig = {
  serverExternalPackages: ['edge-js'],
};

export default nextConfig;

edge-js-pkg

Provides simple access to SQL without the need to write separate C# code.

NOTE This functionality requires IronPython 3.4

NOTE CoreCLR requires dotnet 8

• Inline C# code
  • Passing parameters
  • Using C# class
• Using compiled dll
• Using CoreCLR
• Executing synchronously without function callback
• Using promises/async
• Scripting Node.js from CLR
• Docker

var edge = require('edge-js');

var helloWorld = edge.func(function () {/*
    async (input) => { 
        return ".NET Welcomes " + input.ToString(); 
    }
*/});

helloWorld('JavaScript', function (error, result) {
    if (error) throw error;
    console.log(result);
});

var edge = require('edge-js');

var helloWorld = edge.func(`
    async (input) => { 
        return ".NET Welcomes " + input.ToString(); 
    }
`);

helloWorld('JavaScript', function (error, result) {
    if (error) throw error;
    console.log(result);
});

var edge = require('edge-js');

var helloWorld = edge.func(function () {/*
    async (dynamic input) => { 
        return "Welcome " + input.name + " " + input.surname; 
    }
*/});

helloWorld({name: 'John', surname: 'Smith'}, function (error, result) {
    if (error) throw error;
    console.log(result);
});

var getPerson = edge.func({
    source: function () {/* 
        using System.Threading.Tasks;
        using System;

        public class Person
        {
            public Person(string name, string email, int age)
            {
                Id =  Guid.NewGuid();
                Name = name;
                Email = email;
                Age = age;
            }
            public Guid Id {get;set;}
            public string Name {get;set;}
            public string Email {get;set;}
            public int Age {get;set;}
        }

        public class Startup
        {
            public async Task<object> Invoke(dynamic input)
            {
                return new Person(input.name, input.email, input.age);
            }
        }
    */}
});

getPerson({name: 'John Smith', email: 'john.smith@myemailprovider', age: 35}, function(error, result) {
    if (error) throw error;
    console.log(result);
});

When using inline C# class code must include

public class Startup
{
    public async Task<object> Invoke(object|dynamic input)
    {
        // code
        // return results
    }
}

// People.cs

using System;

namespace People
{
    public class Person
    {
        public Person(string name, string email, int age)
        {
            Id =  Guid.NewGuid();
            Name = name;
            Email = email;
            Age = age;
        }
        public Guid Id {get;}
        public string Name {get;}
        public string Email {get;}
        public int Age {get;}
    }
}

// EdgeJsMethods.cs

using System.Threading.Tasks;
using People;

namespace EdgeJsMethods
{
    class Methods
    {
        public async Task<object> GetPerson(dynamic input)
        {
            return await Task.Run(() => new Person(input.name, input.email, input.age));
        }
    }
}

var edge = require('edge-js');

var getPerson = edge.func({
    assemblyFile: myDll, // path to compiled .dll
    typeName: 'EdgeJsMethods.Methods',
    methodName: 'GetPerson'
});

getPerson({name: 'John Smith', email: 'john.smith@myemailprovider', age: 35}, function(error, result) {
    if (error) throw error;
    console.log(result);
});

public async Task<object> MyMethod(object|dynamic input)
{
    //return results sync/async;
}