# Nemerle is a .NET language built around macros and a self-hosting compiler

> The rsdn/nemerle repository holds the compiler, standard library, macros and IDE integration for Nemerle, a statically typed language for the .NET platform with C#-like syntax and a macro system that can extend the compiler itself. It is also a bootstrapping compiler project whose build runs through xbuild on Mono.

**rsdn/nemerle** — Nemerle language. Main repository.

- Repository: https://github.com/rsdn/nemerle
- Website: http://nemerle.org
- Stars: 640 · Forks: 95
- Language: Nemerle
- License: NOASSERTION
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/rsdn-nemerle

## The language is defined by what the macro system can rewrite

Nemerle is described as a high-level statically-typed programming language for the .NET platform, offering functional, object-oriented and imperative features, with a simple C#-like syntax and a meta-programming system that extends the compiler itself. The feature list makes the shape of the language clear. From the functional side come variants, pattern matching, type inference and parameter polymorphism, which the README calls generics. From the meta-programming side comes compiler extensibility, the ability to embed domain specific languages, partial evaluation and aspect-oriented programming. That last group is the differentiator. The macro system is not a code generation afterthought, it is the mechanism the language is built around, and it is the reason a Nemerle program can carry syntax that does not exist in the base language. The homepage for the project is nemerle.org, and the repository carries a Gitter chat badge, so the language still has a community channel even though the development activity in the git history is modest.

## Hello world is three steps, and the compiler is a Windows exe

The quick sample is deliberately minimal. You create a file called hello.n.

```nemerle
using System.Console;

WriteLine("Hello world")
```

Then you compile and run it with the ncc compiler, which is shipped as an executable in the Nemerle installation directory.

```bat
"C:\Program Files\Nemerle\ncc.exe" hello.n /out:hello.exe
hello.exe
```

The output is the expected line of text.

```bat
Hello world
```

The shape of that command line is the practical detail worth noting. The compiler is invoked as a path to an exe, the source file is passed positionally, and the output path is set with an /out: switch. There is no project file in the sample and no package manifest, so the tool works at the single file level if you want it to.

## Installing means an msi on Windows and a binary tarball on Mono

The install section gives two paths. On Windows you install the latest msi package from nemerle.org. On Linux with Mono you download the latest binary package from the same site and export Nemerle to point at the extracted binaries directory.

That environment variable matters because the build scripts expect it. The build instructions open with cloning the repository with all submodules, using the recursive form of git clone, and pulling with recurse-submodules if you already have a clone. The presence of .gitmodules and a boot/ directory in the listing explains why: the repository carries the binary compiler needed to compile the compiler itself, and it arrives as a submodule. That bootstrap compiler is the reason the build has a staging structure rather than a single command.

## Building the compiler means xbuild on Mono, staged by target framework

The Linux build is the more interesting half because Nemerle can bootstrap itself on Mono. The README gives a generic line that takes a target framework version, a configuration of Release or Debug, and a Stage4 target.

```bash
  xbuild NemerleAll-Mono.nproj /p:TargetFrameworkVersion=v(3.5 or 4.0 or 4.5 or 4.5.1) /p:Configuration=Release(or Debug) /t:Stage4(1 - 4) /tv:4.0(Needed for framework 4.0 and above)   
```

Concrete examples follow for a Release 3.5 build and a Debug 4.0 build.

```bash
  xbuild NemerleAll-Mono.nproj /p:TargetFrameworkVersion=v3.5 /p:Configuration=Release /t:Stage4  
```

```bash
  xbuild NemerleAll-Mono.nproj /p:TargetFrameworkVersion=v4.0 /p:Configuration=Debug /t:Stage4 /tv:4.0
```

The target framework versions on offer are 3.5, 4.0, 4.5 and 4.5.1. Those are the framework generations of the .NET Framework era, and xbuild is the Mono build tool. Both facts date this build path, and both are documented openly rather than hidden, which is at least honest about where the tool sits.

## Windows builds ship an installer, and Visual Studio bindings need VSSDK

The Windows side of the build is script driven, and the top level listing shows how many scripts there are. There are Build-3.5.cmd and Build-4.0.cmd, BuildQuick-ncc.cmd and its per-VS-version variants, DevBuild2Stage.cmd, DevBuildForCommit.cmd, and a set of installer scripts including BuildInstallerFull.cmd, BuildInstallerFast.cmd and their -4 variants, plus GacReg.cmd for the global assembly cache and CleanUp.cmd. The README explains the installer route: you run BuildInstallerFull(fx-version).cmd depending on the required .NET version, and the installer is placed in bin/Release/net-(fx-version)/Installer. There is also BuildInstallerFast(fx-version).cmd for building the installer without running tests. One constraint is called out explicitly: building the Visual Studio bindings requires VSSDK and administrative rights. So the full Windows build is not a single command, and the fastest path is the Fast installer script.

## The IDE story runs through the Visual Studio Shell

The tooling section is the weakest part of the project as it stands. The README lists Visual Studio 2008, 2010, 2012 and 2013-preview integration installed by the Nemerle installer, and Nemerle Studio, described as a free IDE based on Visual Studio Shell in isolated mode, installed by the same installer if the VS Shell was present. A SharpDevelop 3.0 addin can be built manually from snippets/sharpdevelop/ReadMe.txt, and syntax support for Vim, Emacs and Kate lives in the misc folder. The common factor is that every one of these paths is anchored to an IDE generation that has been superseded. There is no mention of a modern IDE integration in the README, and no separate tooling repository is linked. The repository layout reflects the same era, with Nemerle-2005.sln through Nemerle-2012.sln checked in alongside the newer .nproj files, and directories named VsIntegration/ and boot-4.0/.

## The repository is the language, not just a compiler

The repository structure section is where the project stops looking like a compiler and starts looking like a language. ncc/ holds the compiler sources, doc/ the documentation, lib/ the standard Nemerle library, macros/ the standard Nemerle macros, snippets/ examples of Nemerle programs, misc/ tools such as syntax highlighting modes, tools/ for related tools such as a reflector addin, and VsIntegration/ the Visual Studio 2008 integration. Two directories stand out for anyone considering a serious dependency: boot/ and boot-4.0/, described as the binary Nemerle compiler needed to compile itself. That is the defining constraint of the project. A bootstrap compiler checked into the repository is what makes a self-hosting language possible, and it is also what makes the build slow, multi staged and dependent on the toolchain of the era. If you are weighing Nemerle against a mainstream .NET language, this is the axis to weigh it on, because the ecosystem question is really a question about who maintains the bootstrap binaries and the integrations.

## Conclusion

Adopt Nemerle if you are working on .NET and specifically want a language whose compiler you can extend with macros, or you want a readable reference implementation of a bootstrapping compiler. Do not adopt it for a new commercial service, since the last push was on 2026-06-20, the repository publishes no GitHub releases, and the documented toolchain is a Visual Studio Shell IDE plus xbuild on Mono rather than a modern SDK. Verify first by reading License.rtf, which is a custom licence file that GitHub cannot classify, and by trying the hello.n sample with ncc.exe before committing to the language for anything larger.

## FAQ

### What is Nemerle and what language family does it belong to?

Nemerle is a high-level statically-typed programming language for the .NET platform. It offers functional, object-oriented and imperative features, with variants, pattern matching, type inference and parameter polymorphism from the functional side, and a meta-programming system for compiler extensibility, embedded domain specific languages, partial evaluation and aspect-oriented programming.

### How do I compile and run a Nemerle program?

Create a source file such as hello.n, then run the ncc compiler with the output path, for example "C:\Program Files\Nemerle\ncc.exe" hello.n /out:hello.exe, and run the resulting executable. The README shows this producing the expected output line.

### How do I install Nemerle on Linux?

Download the latest binary package from nemerle.org and export Nemerle=/path/to/binaries/extracted so the build scripts can find the toolchain. The Windows path is to install the latest msi package from the same site.

### How do I build the Nemerle compiler from source?

Clone with all submodules using git clone --recursive, then run xbuild against NemerleAll-Mono.nproj with a target framework version and a Stage4 target, for example xbuild NemerleAll-Mono.nproj /p:TargetFrameworkVersion=v3.5 /p:Configuration=Release /t:Stage4. Nemerle can bootstrap itself on Mono.

### Which IDEs support Nemerle?

The README lists Visual Studio 2008, 2010, 2012 and 2013-preview integration installed by the Nemerle installer, plus Nemerle Studio, a free IDE based on the Visual Studio Shell in isolated mode. A SharpDevelop 3.0 addin can be built manually and syntax support for Vim, Emacs and Kate sits in the misc folder.

### What licence does the Nemerle repository use?

The licence is listed as a custom licence that GitHub cannot classify. The repository contains a License.rtf file and a COPYRIGHT file at the top level, and the Makefile in the repository root carries a three clause BSD style notice with a University of Wroclaw copyright covering the redistribution conditions.

## Sources

- [Issues](https://github.com/rsdn/nemerle/issues)
- [Project website](http://nemerle.org)
- [README](https://github.com/rsdn/nemerle/blob/master/README.md)
- [rsdn/nemerle on GitHub](https://github.com/rsdn/nemerle)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/rsdn-nemerle