Iron python VS libuv

I think of IronPython and IronRuby and IronScheme, early attempts at Microsoft trying to combine cornmeal with .NET and open source and calling it a burrito.

  https://ironpython.net/

If you're interested in learning more about the challenges and tradeoffs, both Jython (https://www.jython.org/) and IronPython (https://ironpython.net/) have been around for a long time and there's a lot of reading material on that subject.

There are several ways of bypassing the GIL. First of all, the GIL is only present in the C implementation of Python, CPython. Other implementations of Python like Jython, IronPython, and PyPy don't have the GIL. Additionally, Python provides the multiprocessing library, which allows for parallelism in your Python program.

I am not set on .NET, but just curious, so thanks for the suggestions. Interesting that it's billed as cross-plaform, but doesn't do it that well. I just searched 'python wrapper for .net' and found PythonNET. Also, it seems yes IronPython is active.

You mean like this?

In that case, I think it's enough if you go here, then download and install the MSI file: https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.12

There are quite a lot of ways to run scripting languages in C#. I've no idea what JSR223 is but .NET has DLR for example. There are also multiple libraries: IronPython, NLua, Jint and Jurassic for Javascript. There's also older version of CS-Script working with .NET Framework.

But does it Microsoft python https://ironpython.net

I'm not familiar with the term "context tracking", and management of the event loop is a bit lower level than I normally go, but I do know several runtimes use libuv (https://libuv.org) to handle asynchronous I/O, the same as Node.js (which it was created for).

I'm sure there will be JavaScript runtimes out there using some of Rust's asynchronous schedulers like tokio (https://docs.rs/tokio/latest/tokio/), too, but I wouldn't be surprised if a large number of them just do things bespoke.

libuv Source Code (Version 1.48.0, 2025)

Understanding these phases is critical for predicting the order of execution and debugging performance issues. There's no formal RFC for the event loop itself, but the libuv documentation (https://libuv.org/) is the definitive source.

Libuv describes itself as a multi-platform support library with a focus on asynchronous I/O. It is widely used in many web servers (e.g., Kestrel) and runtimes such as Node.js and Python (via uvloop). As of Zig 0.14.0, there is no native async I/O, so you must work directly with threads or create your own async API using OS primitives like epoll or kqueue. In many cases, you would likely choose a cross-platform library rather than implementing your own async API. That’s where using libuv, libevent, or libxev (written in Zig) becomes useful.

It seems that Bare is also built on top of V8 and libuv, just like Node.js.

> Bare is built on top of https://github.com/holepunchto/libjs, which provides low-level bindings to V8 in an engine independent manner, and https://github.com/libuv/libuv, which provides an asynchronous I/O event loop.(from the README)

Moreover, you actually need Node.js and npm to install and run it. You need another JavaScript runtime as a prerequisite to install this JavaScript runtime…

> npm i -g bare (also from the README)

I don't get it – is it worth it to choose Bare over a more established solution?

The event loop is the core mechanism in Node.js that enables non-blocking I/O operations. Despite Node.js being single-threaded by default, the event loop allows it to perform asynchronous operations by offloading tasks to the system kernel or Libuv's thread pool. This makes Node.js highly efficient for I/O-heavy applications, such as web servers and APIs.

I know good naming is hard, and there are an awful lot of project names that clash, but naming a project uv is unfortunate due to the ubiquitous nature of libuv

https://libuv.org/

Almost everyone running Node in a machine with multiple cores is using multithreading.

Node is multithreaded by default. I believe the default setting is using 4 threads. Most of Node is written in C++.

The JS code written by end users is single threaded (most of it at least) but IO etc is all executed with libuv.

https://libuv.org/