IronPython

Status and roadmap

Jim Hugunin created the project and actively contributed to it up until Version 1.0 which was released on September 5, 2006.{{cite web | access-date = 2006-12-14 | access-date = 2009-01-25 | access-date=2012-04-05

• Release 2.0, released on December 10, 2008, and updated as 2.0.3 on October 23, 2009, targets CPython 2.5.{{cite web | access-date=2010-10-16 | archive-date=2017-12-26 | archive-url=https://web.archive.org/web/20171226082603/http://ironpython.codeplex.com/releases/view/30416 | url-status=dead
• Release 2.6, released on December 11, 2009, and updated on April 12, 2010, targets CPython 2.6.{{cite web | access-date=2010-10-16 | archive-date=2018-01-13 | archive-url=https://web.archive.org/web/20180113101734/http://ironpython.codeplex.com/releases/view/36280 | url-status=dead
• Release 2.7 was released on March 12, 2011 and it targets CPython 2.7.{{cite web | access-date=2011-03-12 | archive-date=2018-01-02 | archive-url=https://web.archive.org/web/20180102233741/http://ironpython.codeplex.com/releases/view/54498 | url-status=dead
• Release 2.7.1 was released on October 21, 2011 and it targets CPython 2.7.{{cite web | access-date=2011-12-30 | archive-date=2017-12-26 | archive-url=https://web.archive.org/web/20171226084555/https://ironpython.codeplex.com/releases/view/62475 | url-status=dead
• Release 2.7.2.1 was released on March 13, 2012. It enables support for ZIP file format libraries, SQLite, and compiled executables.{{cite web | access-date=2012-03-24 | archive-date=2017-12-26 | archive-url=https://web.archive.org/web/20171226082357/http://ironpython.codeplex.com/releases/view/74478 | url-status=dead
• Release 2.7.4 was released on September 7, 2013.{{cite web | access-date=2014-12-07 | archive-date=2018-01-16 | archive-url=https://web.archive.org/web/20180116003231/http://ironpython.codeplex.com/releases/view/90087 | url-status=dead
• Release 2.7.5 was released on December 6, 2014 and mostly consists of bug fixes.{{cite web | access-date=2014-12-07 | archive-date=2018-01-26 | archive-url=https://web.archive.org/web/20180126040129/http://ironpython.codeplex.com/releases/view/169382 | url-status=dead
• Release 2.7.6 was released on August 21, 2016 and only consists of bug fixes.{{cite web | access-date=2016-08-21}}
• Release 2.7.7 was released on December 7, 2016 and only consists of bug fixes.{{cite web | access-date=2018-01-05}}
• Release 2.7.8 was released on February 16, 2018 and consists of bug fixes, reorganized code, and an updated test infrastructure (including significant testing on Linux under Mono). It is also the first release to support .NET Core.{{cite web | access-date=2018-01-05}}
• Release 2.7.9 was released on October 9, 2018 and consists of bug fixes, reorganized code. It is intended to be the last release before IronPython 3.{{cite web | access-date=2018-10-09}}
• Release 2.7.10 was released on April 27, 2020 and adds .NET Core 3.1 support.
• Release 2.7.11 was released on November 17, 2020 and resolves issues when running on .NET 5.
• Release 2.7.12 was released on January 21, 2022 and resolves issues with .NET 6 and removes support for .NET core 2.1
• Release 3.4.0 was released on December 12, 2022 and is the first release to support Python 3.x.

Differences with CPython

There are some differences between the Python reference implementation CPython and IronPython.{{cite web | access-date=2008-02-09}} Some projects built on top of IronPython are known not to work under CPython.{{cite web | access-date=2008-02-09 | archive-url=https://web.archive.org/web/20080830011024/http://lists.ironpython.com/pipermail/users-ironpython.com/2008-January/006297.html | archive-date=2008-08-30 | url-status=dead ,{{cite web | access-date=2008-07-09}} unless they are implemented in a .NET interop. For example, NumPy was wrapped by Microsoft in 2011, allowing code and libraries dependent on it to be run directly from .NET Framework.

Silverlight

IronPython is supported on Silverlight (which is deprecated by Microsoft and already has lost support in most web browsers). It can be used as a scripting engine in the browser just like the JavaScript engine. IronPython scripts are passed like simple client-side JavaScript scripts in ``-tags. It is then also possible to modify embedded XAML markup.

The technology behind this is called Gestalt.

<!-- DLR initialization script. -->
<script src="http://gestalt.ironpython.net/dlr-latest.js" type="text/javascript"></script>

<!-- Client-side script passed to IronPython and Silverlight. -->
<script type="text/python">
    window.Alert("Hello from Python")
</script>

The same works for IronRuby.

License

Until version 0.6, IronPython was released under the terms of Common Public License.{{cite web |access-date=2007-05-13 |url-status=dead |archive-url=https://web.archive.org/web/20100223101738/http://www.ironpython.com/old.html |archive-date=February 23, 2010 | access-date = 2007-05-13 | access-date = 2007-05-13

Interface extensibility

One of IronPython's key advantages is in its function as an extensibility layer to application frameworks written in a .NET language. It is relatively simple to integrate an IronPython interpreter into an existing .NET application framework. Once in place, downstream developers can use scripts written in IronPython that interact with .NET objects in the framework, thereby extending the functionality in the framework's interface, without having to change any of the framework's code base.{{cite web | access-date = 2008-11-18 | archive-url = https://web.archive.org/web/20090114131717/http://www.resolversystems.com/documentation/index.php/Dot_Net_Objects_in_the_Grid | archive-date = 2009-01-14 | url-status = dead

IronPython makes extensive use of reflection. When passed in a reference to a .NET object, it will automatically import the types and methods available to that object. This results in a highly intuitive experience when working with .NET objects from within an IronPython script.

Examples

The following IronPython script manipulates .NET Framework objects. This script can be supplied by a third-party client-side application developer and passed into the server-side framework through an interface. Note that neither the interface, nor the server-side code is modified to support the analytics required by the client application.

from BookService import BookDictionary
 
booksWrittenByBookerPrizeWinners = [book.Title for book in BookDictionary.GetAllBooks() 
                                    if "Booker Prize" in book.Author.MajorAwards]

In this case, assume that the .NET Framework implements a class, BookDictionary, in a module called BookService, and publishes an interface into which IronPython scripts can be sent and executed.

This script, when sent to that interface, will iterate over the entire list of books maintained by the framework, and pick out those written by Booker Prize-winning authors.

What's interesting is that the responsibility for writing the actual analytics reside with the client-side developer. The demands on the server-side developer are minimal, essentially just providing access to the data maintained by the server. This design pattern greatly simplifies the deployment and maintenance of complex application frameworks.

The following script uses the .NET Framework to create a simple Hello World message.

import clr
clr.AddReference("System.Windows.Forms")

from System.Windows.Forms import MessageBox
MessageBox.Show("Hello World")

Performance

The performance characteristics of IronPython compared to CPython, the reference implementation of Python, depends on the exact benchmark used. IronPython performs worse than CPython on most benchmarks taken with the PyStone script but better on other benchmarks.{{cite web | archive-url=https://archive.today/20130119180607/http://ironpython.codeplex.com/Wiki/View.aspx?title=IP26RC1VsCPy26Perf&referringTitle=Home | url-status=dead | archive-date=January 19, 2013 | access-date=2009-10-05 IronPython may perform better in Python programs that use threads or multiple cores, as it has a JIT compiler, and also because it doesn't have the Global Interpreter Lock.{{cite web | access-date=2011-04-04}}

Overview and key features

1. Integration with .NET: IronPython allows you to use .NET libraries and frameworks directly in your Python code. This means you can leverage the extensive .NET ecosystem and access features that are specific to .NET environments.
2. Dynamic Language Runtime (DLR): IronPython runs on the Dynamic Language Runtime, which is a set of services that support dynamic typing and dynamic method invocation in .NET languages.
3. Interoperability: You can call .NET code from IronPython and vice versa. This makes it possible to integrate Python scripts with existing .NET applications or use .NET components within Python projects.
4. Syntax and Semantics: IronPython aims to be as close as possible to the standard Python language (CPython), though there might be minor differences due to the underlying .NET platform.
5. Performance: While IronPython provides good performance for many applications, it might not be as fast as CPython for some tasks, particularly those that rely heavily on Python's native libraries.
6. Compatibility: IronPython is compatible with Python 2.x, but it does not support Python 3.x features. This means that some newer Python libraries or syntax may not be available.

References

References

1. "CodePlex Archive".
2. "IronPython.net".
3. "Python Tools for Visual Studio- Home". Python Tools for Visual Studio.
4. "Dynamic Language Runtime Overview". [[Microsoft]].
5. "2009-07-02 Marek Safar · mono/Mono@340222f".
6. "IronLanguages/ironpython2".
7. "Releases · IronLanguages/ironpython2".
8. "Releases · IronLanguages/ironpython3".
9. "NumPy and SciPy for .NET".
10. "Silverlight 5 System Requirements".
11. "Write browser applications in Python". IronPython.net.
12. "Python's Hardest Problem, Revisited".