1. Project Overview & Quickstart (nim-lang/highlite.html)

highlite.html

Open-source repository nim-lang/highlite.html

Repository Details

Repository: nim-lang/highlite.html
Primary Language: Code

Note: High-volume repository documentation is actively indexed and synchronized by YakaAI.

2. Official Technical Reference & Guides (nim-lang/website)

File: README.md

Nim website development

The Nim website hosted on https://nim-lang.org.

Developing

Install Jekyll, then cd jekyll and use bundle exec jekyll serve
to serve to a local Web server with automatic refresh on changes.

License

Unless otherwise stated, the content of this page is licensed under the Creative Commons Attribution 3.0 license.

The design of this website is Copyright (C) Nim developers.

File: LICENSE.md

Attribution 3.0 Unported (CC BY 3.0)
Copyright (C) 2023 The Nim Programming language

You are free to

Share — copy and redistribute the material in any medium or format
Adapt — remix, transform, and build upon the material for any purpose, even commercially.

The licensor cannot revoke these freedoms as long as you follow the license terms.

Under the following terms

Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
No additional restrictions — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.

Notices

You do not have to comply with the license for elements of the material in the public domain or where your use is permitted by an applicable exception or limitation.
No warranties are given. The license may not give you all of the permissions necessary for your intended use. For example, other rights such as publicity, privacy, or moral rights may limit how you use the material.

For more details

https://creativecommons.org/licenses/by/3.0/

File: jekyll/_config.yml

Site settings

title: "Nim Programming Language"
The Nim programming language is a concise, fast programming language that
compiles to C, C++ and JavaScript.
url: "https://nim-lang.org/"
baseurl: ""

nim_version: 2.2.12

future: true

defaults:

text

scope:
  path: ""
  type: pages
values:
  layout: default

scope:
path: ""
type: posts
values:
layout: post
is_post: true
title: "Nim Blog"

navigation:

title: Blog
url: /blog.html
title: Features
url: /features.html
title: Download
url: /install.html
title: Documentation
url: /documentation.html
title: Forum
url: https://forum.nim-lang.org
title: Donate
url: /donate.html

Build settings

markdown: kramdown
permalink: /blog/:year/:month/:day/:title.html
sass:
style: compressed
exclude:

CNAME
README.md
LICENSE.md

plugins:

jekyll-asciidoc

asciidoc: {}
asciidoctor:
attributes:
- imagesdir=/assets/news/images/asciidoc
- icons=font
- source-highlighter=rouge

File: jekyll/community.md

layout: page title: Community css_class: community

Community

No matter the communication medium, we hope that you will find a place in our community. Just remember to [be kind](https://boz.com/articles/be-kind).

Chat rooms

By far the quickest and easiest way to get involved in our community is
by joining one of our chat rooms.

Our official chat room is the #nim channel on irc.libera.chat. You can
access it in multiple ways:

Use an IRC client
to connect to irc.libera.chat and join the #nim channel. You can also view
the IRC Logs.

Join the Discord chat room, which relays messages both ways between IRC and Discord, by clicking [here](https://discord.gg/nim).

Join the Gitter chat room, which relays messages both ways between Matrix and
Gitter, by clicking here.

m
Join the Matrix chat room, which relays messages both ways between Discord and
Matrix, by clicking here.

Join the Telegram chat room, which relays messages both ways between Discord and
Telegram by clicking here. There is also an italian
Telegram that can be accessed by clicking here.

You can join this chat room to ask a quick question, or engage in a discussion
about features and projects that interest you. For formal feature requests and
issue reporting consult the Issues and RFCs section.

Be aware that all messages in Gitter, Discord, Matrix and IRC are logged.
You can access the IRC logs of the #nim channel
here.

The #nim channel is primarily for on-topic discussion. There is also an
official #nim-offtopic channel for off-topic discussion.

If you dislike being logged, there is also a #nim-nologs channel.

Forum

This is a good place for long questions or to gauge the community's interest
on specific topics such as new features.

Nim forum

Twitter

For announcements including news about releases, events and projects. Be sure
to follow the official Twitter account and remember to mention
the account when tweeting about Nim!

@nim_lang

Blog

The blog is where we will be posting release announcements and other news first.
If you are an avid RSS user then it should be just for you.

[Nim blog]({{ site.baseurl }}/blog.html)

[Blog feed]({{ '/feed.xml' | prepend: site.baseurl }})

The Nim subreddit contains many user-submitted announcements, blog posts,
discussions. It is a good place to share your work with the Nim community and
to get updates about the project so be sure to hit that subscribe button.

r/nim

StackOverflow

There is already an active number of Nim developers answering questions on
StackOverflow, you can be one of them. It is also a good place for newcomers to
get help with their project. Be sure to use the nim tag when asking
questions.

nim

Meetups

If you're planning on organising a Nim meetup, please let us know, we would
love to include it here and announce it via Twitter and other means.

As of right now, there don't appear to be any active meetups, although the
following groups have been set up:

Issues and RFCs

The issue tracker is hosted on GitHub together with the main repository.
Most projects under the Nim umbrella have their own issue tracker:

If you have found an issue in the compiler, the standard library or any of
the tools then please create an issue in the relevant repository. If
appropriate include a minimal example reproducing the issue.

If you have a feature request, then consider creating a formal RFC
(Request For Comments). In it you should describe the feature clearly,
including the use cases that you foresee for the feature and anything else
that you think is relevant. RFCs are currently submitted to the
issue tracker.

Wiki

A good place for general user-submitted articles and content. For instance,
things like random howtos, tutorials, notes, links to interesting content,
and so on. It's also a good place to post material or ideas that come up
during forum or IRC chats, for instance.

It's hosted on GitHub, but also very easy for anyone to edit and share
quickly, without needing to make pull requests.

Nim wiki

Users and contributors map

{% include map.html %}

File: jekyll/donate.md

layout: default title: Donate css_class: donate

Donate

Fund Nim to support its development or find out about the commercial support that we offer.

Open Collective

text

Help us with the Nim development by contributing on Open Collective.
    
  

<a class="pure-button pure-button-primary" href="https://opencollective.com/nim">Learn more</a>
<a class="pure-button" href="#other-ways-to-donate">Other ways to donate</a>

Commercial support

We offer a multitude of support networks including those in both a community
and commercial setting.

Commercial support includes priority bug fixes and feature requests. All
interested parties should email [email protected]. The bid for
contracting work is a commercial offer provided by:

Andreas Rumpf
St.-Quentin-Ring 47
67663 Kaiserslautern
GERMANY
EU VAT-IN: DE297783450

Priority bug fixes

File a bug report; we will address it with the highest priority.
Once fixed, you will be able to access either the current Git build or
at your request a custom build against the latest release with your bug fixed.

Feature requests

Suggest to us any feature that you might need. We will examine your request
with care and provide a proper answer about its potential for inclusion.

Communication happens via email or for a slightly higher fee via Skype.
The pricing is based on the amount of hours spent on the bugfix / feature
implementation and is open to negotiation.

Other ways to donate

Apart from Open Collective, you can also donate
to Nim using one the following services:

Patreon

bc1qzgw3vsppsa9gu53qyecyu063jfajmjpye3r2h4

0xC1d472B409c1bdCd8C0E45515D18F08a55fE9fa8

Nano: nano_1hioyj6n1nw5tpiq8rk8g1er6pfhfuuxqm88eog19d7qkhpbyic4whzqymbd

File: jekyll/faq.md

layout: page title: FAQ css_class: faq

Frequently Asked Questions

General questions

Why yet another programming language?

Nim is one of the very few programmable statically typed languages, and
combines the speed and memory efficiency of C, an expressive syntax,
memory safety and multiple target languages.

How stable is Nim?

The compiler and stdlib are actively under development and have a suite of test
cases to ensure ongoing stability. Regular releases are posted every three to
six months that can be used as a base for projects requiring a stable foundation.
Breaking changes are rare but are documented
in detail and can typically be managed with minimal effort. The compiler also
highlights deprecated features to provide sufficient notice and transition time
through changes.

How about security and memory safety?

Nim provides memory safety by not performing pointer arithmetic, with
optional checks, traced and untraced references and optional non-nullable types.
It supports Valgrind through the koch tool, and taint analysis.

How is Nim licensed?

The Nim compiler and the library are MIT licensed.
This means that you can use any license for your own programs developed with
Nim.

What about JVM/CLR backends?

JVM/CLR support is not in the nearest plans. However, since these VMs support FFI to C
it should be possible to create native Nim bridges, that transparently generate all the
glue code thanks to powerful metaprogramming capabilities of Nim.

What about editor support?

Visual Studio Code: Official extension https://marketplace.visualstudio.com/items?itemName=NimLang.nimlang
VSCodium/OpenVSX: https://open-vsx.org/extension/nimsaem/nimvscode
Emacs: https://github.com/nim-lang/nim-mode
Vim: https://github.com/zah/nimrod.vim/
NeoVim: https://github.com/alaviss/nim.nvim
Helix: https://github.com/nim-lang/langserver
QtCreator (4.1+): Included as experimental plugin.
Scite: Included
Gedit: The Aporia .lang file.
Geany: Included
jEdit: https://github.com/exhu/nimrod-misc/tree/master/jedit
TextMate: https://github.com/textmate/nim.tmbundle
Sublime Text: https://github.com/Varriount/NimLime
LiClipse: http://www.liclipse.com/ (Eclipse based plugin)
Howl: Included
Notepad++: https://github.com/jangko/nppnim/releases
Micro: Included
Atom: https://atom.io/packages/nim
JetBrains IDEs: https://plugins.jetbrains.com/plugin/15128-nim
Kakoune: Included
For editors with LSP (Language Server Protocol) support (requires a separate syntax/indenting plugin): https://github.com/PMunch/nimlsp

What have been the major influences in the language's design?

The language borrows heavily from (in order of impact): Modula 3, Delphi,
Ada, C++, Python, Lisp, Oberon.

Why is it named ``proc``?

Procedure used to be the common term as opposed to a function which is a
mathematical entity that has no side effects. And indeed in Nim func
is syntactic sugar for proc {.noSideEffect.}. Naming it def would not
make sense because Nim also provides an iterator and a method keyword,
whereas def stands for define.

Compilation FAQ

Which option to use for the fastest executable?

For the standard configuration file, -d:danger makes the fastest binary possible
while disabling all runtime safety checks including bound checks, overflow checks,
nil checks and more; for most cases -d:release should
be enough. If supported by your compiler, you can also enable link-time optimization
for an even faster executable: --passc:-flto or -d:lto on Nim 1.4+

Which option to use for the smallest executable?

For the standard configuration file, -d:danger -d:strip --opt:size does the trick.
If supported by your compiler, you can also enable link-time optimization
the same way as described in the previous answer.

How do I use a different C compiler than the default one?

Edit the config/nim.cfg file.
Change the value of the cc variable to one of the following:

Abbreviation	C/C++ Compiler
`gcc`	GNU C compiler
`clang`	Clang compiler
`vcc`	Microsoft's Visual C++
`icc`	Intel C compiler
`llvm_gcc`	LLVM-GCC compiler
`tcc`	Tiny C compiler
`bcc`	Borland C compiler
`envcc`	Your environment's default C compiler

Other C compilers are not officially supported, but might work too.

If your C compiler is not in the above list, try using the
environment's default C compiler (envcc). If the C compiler needs
different command line arguments try the --passc and --passl switches.

File: jekyll/install.md

layout: default title: Download css_class: install

Install Nim

text

<a href="{{ site.baseurl }}/install_windows.html">
    
      
    
    <h2>Windows</h2>
  </a>



  <a href="{{ site.baseurl }}/install_unix.html">
    
      
      
    
    <h2>Unix</h2>
  </a>

text

Want a nightly build?
</h1>

  
    
      We offer nightly builds both for the cutting-edge devel branch and
      for backports to our stable branch.
    
  
  
    <a class="pure-button" href="https://github.com/nim-lang/nightlies/releases">Get nightlies</a>

Install previous versions

Version	Windows	Linux	macOS	Source
{{ version }}	{% if assets.windows_x64 %}[x86_64]({{ assets.windows_x64.github_url }}) [sha]({{ assets.windows_x64.github_url }}.sha256){% endif %}

text

{% if assets.windows_x32 %}[x86]({{ assets.windows_x32.github_url }}) [sha]({{ assets.windows_x32.github_url }}.sha256){% endif %} | {% if assets.linux_x64 %}[x86_64]({{ assets.linux_x64.github_url }}) [sha]({{ assets.linux_x64.github_url }}.sha256){% endif %}
      {% if assets.linux_x32 %}[x86]({{ assets.linux_x32.github_url }}) [sha]({{ assets.linux_x32.github_url }}.sha256){% endif %}
      {% if assets.linux_arm64 %}[ARM64]({{ assets.linux_arm64.github_url }}) [sha]({{ assets.linux_arm64.github_url }}.sha256){% endif %}
      {% if assets.linux_armv7l %}[ARMv7]({{ assets.linux_armv7l.github_url }}) [sha]({{ assets.linux_armv7l.github_url }}.sha256){% endif %} | {% if assets.macosx_arm64 %}[ARM64]({{ assets.macosx_arm64.github_url }}) [sha]({{ assets.macosx_arm64.github_url }}.sha256){% endif %}
      {% if assets.macosx_x64 %}[x86_64]({{ assets.macosx_x64.github_url }}) [sha]({{ assets.macosx_x64.github_url }}.sha256){% endif %} | {% if assets.source_tar %}[tar.xz]({{ assets.source_tar.github_url }}) [sha]({{ assets.source_tar.github_url }}.sha256){% endif %} |

File: jekyll/install_unix.md

layout: page title: Unix installation css_class: install_unix current: Install

{% assign current_release = site.data.nim_releases[site.nim_version] %}

Install Nim on Unix

Installation using ``choosenim``

choosenim is an
installer for the Nim programming language. It allows you
to easily switch between versions of Nim, whether that is the latest stable
release or the latest development version.

To install the latest stable release of Nim using choosenim, just run the
following in your terminal, then follow the onscreen instructions:

bash

curl https://nim-lang.org/choosenim/init.sh -sSf | sh

Manual installation

Pre-built binaries for Linux

{% if current_release.linux_x64 %}
If you're not sure which version (64-bit or 32-bit) to pick, it is very likely
that you want the 64-bit version (x86_64):

{% assign url = current_release.linux_x64.nimlang_url | default: current_release.linux_x64.github_url %}

text

Download x86_64 tarball

text

SHA256

{% endif %}

{% if current_release.linux_x32 %}
If you know what you're doing and you're sure you need a 32-bit version,
you can download it below:

{% assign url = current_release.linux_x32.nimlang_url | default: current_release.linux_x32.github_url %}

text

Download x86 tarball

text

SHA256

{% endif %}

{% if current_release.linux_arm64 %}
For ARM64 (aarch64) systems:

{% assign url = current_release.linux_arm64.nimlang_url | default: current_release.linux_arm64.github_url %}

text

Download ARM64 tarball

text

SHA256

{% endif %}

{% if current_release.linux_armv7l %}
For ARMv7 (armv7l) systems:

{% assign url = current_release.linux_armv7l.nimlang_url | default: current_release.linux_armv7l.github_url %}

text

Download ARMv7 tarball

text

SHA256

{% endif %}

{% if current_release.macosx_arm64 or current_release.macosx_x64 %}

Pre-built binaries for macOS

{% if current_release.macosx_arm64 %}
For Apple Silicon (M1/M2/M3) Macs:

{% assign url = current_release.macosx_arm64.nimlang_url | default: current_release.macosx_arm64.github_url %}

text

Download ARM64 tarball

text

SHA256

{% endif %}

{% if current_release.macosx_x64 %}
For Intel Macs:

{% assign url = current_release.macosx_x64.nimlang_url | default: current_release.macosx_x64.github_url %}

text

Download x86_64 tarball

text

SHA256

{% endif %}
{% endif %}

{% if current_release.source_tar %}

Source archive

{% assign url = current_release.source_tar.nimlang_url | default: current_release.source_tar.github_url %}

text

Download source tarball

text

SHA256

{% endif %}

After downloading the compressed archive, extract its contents into the
desired installation directory. Pre-built binaries are provided in the
binary distribution.

For the source distribution, open a new terminal window, cd into the
extracted directory, and execute the following commands:

bash

sh build.sh
bin/nim c koch
./koch boot -d:release
./koch tools

Configuring the ``PATH`` environment variable for a manual installation

The compiler and tool binaries live inside the bin directory.
It is common for Nim developers to include two directories in their
PATH environment variable:

the aforementioned bin directory
~/.nimble/bin (where ~ is the home directory)

Notes about compiler dependencies

The Nim compiler needs a C compiler in order to compile software. You must
install this separately and ensure that it is in your PATH.

macOS

Simply install the latest version of clang available on your system.
You can do this by:

Opening a new terminal window
Executing xcode-select --install
Clicking on the "Install" button in the dialog box that appears.

Source: Quora

Linux

You probably already have a compiler installed. If not, use your package
manager to install either gcc or clang.

Other dependencies

There are a number of other dependencies that you may need to install in order
to use Nim. They include:

PCRE
OpenSSL

You can use your package manager to install these dependencies when
necessary.

Installation using package managers

Arch Linux

text

pacman -S nim

Debian / Ubuntu

text

apt-get install nim

Docker

The official Docker images
are published on Docker Hub and include
the compiler and Nimble.

Get the latest image:

text

docker pull nim

Fedora

Requires Terra (Third party repository).

text

dnf install nim

Alternatively, install nim-nightly or choosenim.

FreeBSD

text

pkg install nim

macOS

text

brew install nim

OpenBSD

text

pkg_add nim

openSUSE

text

zypper in nim

Void Linux

text

xbps-install -S nim

File: jekyll/install_windows.md

layout: page title: Windows installation css_class: install_windows current: Install

Install Nim on Windows

Manual installation

If you are not sure which version (64-bit or 32-bit) to pick, it is very likely
that you want the 64-bit version (x86_64):

text

Download x86_64 zip

text

SHA256

If you know what you are doing and you are sure you need a 32-bit version,
you can download it below:

text

Download x86 zip

text

SHA256

The installation using the provided zip files should be fairly
straightforward. Simply extract the files into the desired installation
directory, and run finish.exe.

Configuring the ``PATH`` environment variable

The binaries from the zip file live inside the bin directory.
It is common for Nim developers to include two directories in their
PATH environment variable:

the aforementioned bin directory
%USERPROFILE%\.nimble\bin (where %USERPROFILE% is the home directory)

The zip file includes a simple application called finish.exe that can
attempt to add both directories to your PATH.
This tool also checks for the presence of a C compiler and can install MingW,
the GNU C compiler collection for Windows.

Compiler dependencies

The Nim compiler needs a C compiler in order to compile software. You can
use finish.exe to install MinGW.

The following versions of MinGW are known to work with the latest version of
Nim:

32 bit - [mingw32.7z]({{ site.baseurl }}/download/mingw32.7z) ([SHA256]({{ site.baseurl }}/download/mingw32.7z.sha256))
64 bit - [mingw64.7z]({{ site.baseurl }}/download/mingw64.7z) ([SHA256]({{ site.baseurl }}/download/mingw64.7z.sha256))

Installation using ``choosenim``

choosenim is an
installer for the Nim programming language. It allows you
to easily switch between versions of Nim, whether that is the latest stable
release or the latest development version.

File: jekyll/releases.json

layout: null

File: jekyll/_data/nim_releases.json

File: jekyll/_data/sponsors_meta.json

{
"last_update": "2019-07-04"
}

File: jekyll/_posts/2009-12-21-version-086-released.md

title: "Version 0.8.6 released" author: Andreas Rumpf

The version jump from 0.8.2 to 0.8.6 acknowledges the fact that all development
of the compiler is now done in Nimrod.

Bugfixes

The pragmas hint[X]:off and warning[X]:off now work.
Method call syntax for iterators works again (for x in lines.split()).
Fixed a typo in removeDir for POSIX that lead to an infinite recursion.
The compiler now checks that module filenames are valid identifiers.
Empty patterns for the dynlib pragma are now possible.
os.parseCmdLine returned wrong results for trailing whitespace.
Inconsequent tuple usage (using the same tuple with and without named fields)
does not crash the code generator anymore.
A better error message is provided when the loading of a proc within a
dynamic lib fails.

Additions

Added system.contains for open arrays.
The PEG module now supports the search loop operator @.
Grammar/parser: SAD|IND is allowed before any kind of closing bracket.
This allows for more flexible source code formatting.
The compiler now uses a bind table for symbol lookup within a bind
context. (See manual.html#templates for details.)
discard """my long comment""" is now optimized away.
New --floatChecks: on|off switches and pragmas for better debugging
of floating point operations. (See
manual.html#types-pre-defined-floating-point-types for details.)
The manual has been improved. (Many thanks to Philippe Lhoste!)

Changes affecting backwards compatibility

The compiler does not skip the linking step anymore even if no file
has changed.
os.splitFile(".xyz") now returns ("", ".xyz", "") instead of
("", "", ".xyz"). So filenames starting with a dot are handled
differently.
strutils.split(s: string, seps: set[char]) never yields the empty string
anymore. This behaviour is probably more appropriate for whitespace splitting.
The compiler now stops after the --version command line switch.
Removed support for enum inheritance in the parser; enum inheritance has
never been documented anyway.
The msg field of system.E_base has now the type string, instead
of cstring. This improves memory safety.

File: jekyll/_posts/2010-03-14-version-088-released.md

title: "Version 0.8.8 released" author: Andreas Rumpf

Bugfixes

The Posix version of os.copyFile has better error handling.
Fixed bug #502670 (underscores in identifiers).
Fixed a bug in the parsexml module concerning the parsing of
<tag attr="value" />.
Fixed a bug in the parsexml module concerning the parsing of
enities like &ltXX.
system.write(f: TFile, s: string) now works even if s contains binary
zeros.
Fixed a bug in os.setFilePermissions for Windows.
An overloadable symbol can now have the same name as an imported module.
Fixed a serious bug in strutils.cmpIgnoreCase.
Fixed unicode.toUTF8.
The compiler now rejects '\n' (use "\n" instead).
times.getStartMilsecs() now works on Mac OS X.
Fixed a bug in pegs.match concerning start offsets.
Lots of other little bugfixes.

Additions

Added system.cstringArrayToSeq.
Added system.lines(f: TFile) iterator.
Added system.delete, system.del and system.insert for sequences.
Added system./ for int.
Exported system.newException template.
Added cgi.decodeData(data: string): tuple[key, value: string].
Added strutils.insertSep.
Added math.trunc.
Added ropes module.
Added sockets module.
Added browsers module.
Added httpserver module.
Added httpclient module.
Added parseutils module.
Added unidecode module.
Added xmldom module.
Added xmldomparser module.
Added xmltree module.
Added xmlparser module.
Added htmlparser module.
Added re module.
Added graphics module.
Added colors module.
Many wrappers now do not contain redundant name prefixes (like GTK_,
lua). The old wrappers are still available in lib/oldwrappers.
You can change your configuration file to use these.
Triple quoted strings allow for " in more contexts.
"" within raw string literals stands for a single quotation mark.
Arguments to openArray parameters can be left out.
More extensive subscript operator overloading. (To be documented.)
The documentation generator supports the .. raw:: html directive.
The Pegs module supports back references via the notation $capture_index.

Changes affecting backwards compatibility

Overloading of the subscript operator only works if the type does not provide
a built-in one.
The search order for libraries which is affected by the path option
has been reversed, so that the project's path is searched before
the standard library's path.
The compiler does not include a Pascal parser for bootstrapping purposes any
more. Instead there is a pas2nim tool that contains the old functionality.
The procs os.copyFile and os.moveFile have been deprecated
temporarily, so that the compiler warns about their usage. Use them with
named arguments only, because the parameter order will change the next
version!
atomic and let are now keywords.
The \w character class for pegs now includes the digits '0'..'9'.
Many wrappers now do not contain redundant name prefixes (like GTK_,
lua) anymore.
Arguments to openArray parameters can be left out.

File: jekyll/_posts/2010-10-20-version-0810-released.md

title: "Version 0.8.10 released" author: Andreas Rumpf

Bugfixes

Bugfix: Command line parsing on Windows and os.parseCmdLine now adheres
to the same parsing rules as Microsoft's C/C++ startup code.
Bugfix: Passing a ref pointer to the untyped pointer type is invalid.
Bugfix: Updated keyval example.
Bugfix: system.splitChunk still contained code for debug output.
Bugfix: dialogs.ChooseFileToSave uses STOCK_SAVE instead of
STOCK_OPEN for the GTK backend.
Bugfix: Various bugs concerning exception handling fixed.
Bugfix: low(somestring) crashed the compiler.
Bugfix: strutils.endsWith lacked range checking.
Bugfix: Better detection for AMD64 on Mac OS X.

Changes affecting backwards compatibility

Reversed parameter order for os.copyFile and os.moveFile!!!
Procs not marked as procvar cannot only be passed to a procvar anymore,
unless they are used in the same module.
Deprecated times.getStartMilsecs: Use epochTime or cpuTime
instead.
Removed system.OpenFile.
Removed system.CloseFile.
Removed strutils.replaceStr.
Removed strutils.deleteStr.
Removed strutils.splitLinesSeq.
Removed strutils.splitSeq.
Removed strutils.toString.
If a DLL cannot be loaded (via the dynlib pragma) EInvalidLibrary
is not raised anymore. Instead system.quit() is called. This is because
raising an exception requires heap allocations. However the memory manager
might be contained in the DLL that failed to load.
The re module (and the pcre wrapper) now depend on the pcre dll.

Additions

The {.compile: "file.c".} pragma uses a CRC check to see if the file
needs to be recompiled.
Added system.reopen.
Added system.getCurrentException.
Added system.appType.
Added system.compileOption.
Added times.epochTime and times.cpuTime.
Implemented explicit type arguments for generics.
Implemented {.size: sizeof(cint).} pragma for enum types. This is useful
for interfacing with C.
Implemented {.pragma.} pragma for user defined pragmas.
Implemented {.extern.} pragma for better control of name mangling.
The importc and exportc pragmas support format strings:
proc p{.exportc: "nim_$1".} exports p as nim_p. This is useful
for user defined pragmas.
The standard library can be built as a DLL. Generating DLLs has been
improved.
Added expat module.
Added json module.
Added support for a Tiny C backend. Currently this only works on Linux.
You need to bootstrap with -d:tinyc to enable Tiny C support. Nimrod
can then execute code directly via nimrod run myfile.

File: jekyll/_posts/2011-07-10-version-0812-released.md

title: "Version 0.8.12 released" author: Andreas Rumpf

Bugfixes

Bugfix: httpclient correct passes the path starting with /.
Bugfixes for the htmlparser module.
Bugfix: pegs.find did not respect start parameter.
Bugfix: dialogs.ChooseFilesToOpen did not work if only one file is
selected.
Bugfix: niminst: nimrod is not default dir for every project.
Bugfix: Multiple yield statements in iterators did not cause local vars to be
copied.
Bugfix: The compiler does not emit very inaccurate floating point literals
anymore.
Bugfix: Subclasses are taken into account for try except matching.
Bugfix: Generics and macros are more stable. There are still known bugs left
though.
Bugfix: Generated type information for tuples was sometimes wrong, causing
random crashes.
Lots of other bugfixes: Too many to list them all.

Changes affecting backwards compatibility

Operators starting with ^ are now right-associative and have the highest
priority.
Deprecated os.getApplicationFilename: Use os.getAppFilename instead.
Deprecated os.getApplicationDir: Use os.getAppDir instead.
Deprecated system.copy: Use substr or string slicing instead.
Changed and documented how generalized string literals work: The syntax
module.re"abc" is now supported.
Changed the behaviour of strutils.%, ropes.%
if both notations $# and $i are involved.
The pegs and re modules distinguish between replace
and replacef operations.
The pointer dereference operation p^ is deprecated and might become
^p in later versions or be dropped entirely since it is rarely used.
Use the new notation p[] in the rare cases where you need to
dereference a pointer explicitly.
system.readFile does not return nil anymore but raises an EIO
exception instead.
Unsound co-/contravariance for procvars has been removed.

Language Additions

Source code filters are now documented.
Added the linearScanEnd, unroll, shallow pragmas.
Added emit pragma for direct code generator control.
Case statement branches support constant sets for programming convenience.
Tuple unpacking is not enforced in for loops anymore.
The compiler now supports array, sequence and string slicing.
A field in an enum may be given an explicit string representation.
This yields more maintainable code than using a constant
array[TMyEnum, string] mapping.
Indices in array literals may be explicitly given, enhancing readability:
[enumValueA: "a", enumValueB: "b"].
Added thread support via the threads core module and
the --threads:on command line switch.
The built-in iterators system.fields and system.fieldPairs can be
used to iterate over any field of a tuple. With this mechanism operations
like == and hash are lifted to tuples.
The slice .. is now a first-class operator, allowing code like:
x in 1000..100_000.

Compiler Additions

The compiler supports IDEs via the new group of idetools command line
options.
The interactive mode (REPL) has been improved and documented for the
first time.
The compiler now might use hashing for string case statements depending
on the number of string literals in the case statement.

Library Additions

Added lists module which contains generic linked lists.
Added sets module which contains generic hash sets.
Added tables module which contains generic hash tables.
Added queues module which contains generic sequence based queues.
Added intsets module which contains a specialized int set data type.
Added scgi module.
Added smtp module.
Added encodings module.
Added re.findAll, pegs.findAll.
Added os.findExe.
Added parseutils.parseUntil and parseutils.parseWhile.
Added strutils.align, strutils.tokenize, strutils.wordWrap.
Pegs support a captured search loop operator {@}.
Pegs support new built-ins: \letter, \upper, \lower,
\title, \white.
Pegs support the new built-in \skip operation.
Pegs support the $ and ^ anchors.
Additional operations were added to the complex module.
Added strutils.formatFloat, strutils.formatBiggestFloat.
Added unary < for nice looking excluding upper bounds in ranges.
Added math.floor.
Added system.reset and a version of system.open that
returns a TFile and raises an exception in case of an error.
Added a wrapper for redis.
Added a wrapper for 0mq via the zmq module.
Added a wrapper for sphinx.
Added system.newStringOfCap.
Added system.raiseHook and system.outOfMemHook.
Added system.writeFile.
Added system.shallowCopy.
system.echo is guaranteed to be thread-safe.
Added prelude include file for scripting convenience.
Added typeinfo core module for access to runtime type information.
Added marshal module for JSON serialization.

File: jekyll/_posts/2012-02-09-version-0814-released.md

title: "Version 0.8.14 released" author: Andreas Rumpf

Version 0.8.14 has been released!

Bugfixes

Fixed a serious memory corruption concerning message passing.
Fixed a serious bug concerning different instantiations of a generic proc.
Fixed a newly introduced bug where a wrong EIO exception was raised for
the end of file for text files that do not end with a newline.
Bugfix c2nim, c2pas: the --out option has never worked properly.
Bugfix: forwarding of generic procs never worked.
Some more bugfixes for macros and compile-time evaluation.
The GC now takes into account interior pointers on the stack which may be
introduced by aggressive C optimizers.
Nimrod's native allocator/GC now works on PowerPC.
Lots of other bugfixes: Too many to list them all.

Changes affecting backwards compatibility

Removed deprecated os.AppendFileExt, os.executeShellCommand,
os.iterOverEnvironment, os.pcDirectory, os.pcLinkToDirectory,
os.SplitPath, os.extractDir, os.SplitFilename,
os.extractFileTrunk, os.extractFileExt, osproc.executeProcess,
osproc.executeCommand.
Removed deprecated parseopt.init, parseopt.getRestOfCommandLine.
Moved strutils.validEmailAddress to matchers.validEmailAddress.
The pointer dereference operator ^ has been removed, so that ^
can now be a user-defined operator.
implies is no keyword anymore.
The is operator is now the of operator.
The is operator is now used to check type equivalence in generic code.
The pure pragma for procs has been renamed to noStackFrame.
The threading API has been completely redesigned.
The unidecode module is now thread-safe and its interface has changed.
The bind expression is deprecated, use a bind declaration instead.
system.raiseHook is now split into system.localRaiseHook and
system.globalRaiseHook to distinguish between thread local and global
raise hooks.
Changed exception handling/error reporting for os.removeFile and
os.removeDir.
The algorithm for searching and loading configuration files has been changed.
Operators now have diffent precedence rules: Assignment-like operators
(like *=) are now special-cased.
The fields in TStream have been renamed to have an Impl suffix
because they should not be used directly anymore.
Wrapper procs have been created that should be used instead.
export is now a keyword.
assert is now implemented in pure Nimrod as a template; it's easy
to implement your own assertion templates with system.astToStr.

Language Additions

Added new is and of operators.
The built-in type void can be used to denote the absence of any type.
This is useful in generic code.
Return types may be of the type var T to return an l-value.
The error pragma can now be used to mark symbols whose usage should trigger
a compile-time error.
There is a new discardable pragma that can be used to mark a routine
so that its result can be discarded implicitly.
Added a new noinit pragma to prevent automatic initialization to zero
of variables.
Constants can now have the type seq.
There is a new user-definable syntactic construct a{i, ...}
that has no semantics yet for built-in types and so can be overloaded to your
heart's content.
bind (used for symbol binding in templates and generics) is now a
declarative statement.
Nimrod now supports single assignment variables via the let statement.
Iterators named items and pairs are implicitly invoked when
an explicit iterator is missing.
The slice assignment a[i..j] = b where a is a sequence or string
now supports splicing.

Compiler Additions

The compiler can generate C++ code for easier interfacing with C++.
The compiler can generate Objective C code for easier interfacing with
Objective C.
The new pragmas importcpp and importobjc make interfacing with C++
and Objective C somewhat easier.
Added a new pragma incompleteStruct to deal with incomplete C struct
definitions.
Added a --nimcache:PATH configuration option for control over the output
directory for generated code.
The --genScript option now produces different compilation scripts
which do not contain absolute paths.
Added --cincludes:dir, --clibdir:lib configuration options for
modifying the C compiler's header/library search path in cross-platform way.
Added --clib:lib configuration option for specifying additional
C libraries to be linked.
Added --mainmodule:file configuration options for specifying the main
project file. This is intended to be used in project configuration files to
allow commands like nimrod c or nimrod check to be executed anywhere
within the project's directory structure.
Added a --app:staticlib option for creating static libraries.
Added a --tlsEmulation:on|off switch for control over thread local
storage emulation.
The compiler and standard library now support a taint mode. Input strings
are declared with the TaintedString string type. If the taint
mode is turned on it is a distinct string type which helps to detect input
validation errors.
The compiler now supports the compilation cache via --symbolFiles:on.
This potentially speeds up compilations by an order of magnitude, but is
still highly experimental!
Added --import:file and --include:file configuration options
for specifying modules that will be automatically imported/incluced.
nimrod i can now optionally be given a module to execute.
The compiler now performs a simple alias analysis to generate better code.
The compiler and ENDB now support watchpoints.
The compiler now supports proper compile time expressions of type bool
for on|off switches in pragmas. In order to not break existing code,
on and off are now aliases for true and false and declared
in the system module.
The compiler finally supports closures. This is a preliminary
implementation, which does not yet support nestings deeper than 1 level
and still has many known bugs.

Library Additions

Added system.allocShared, system.allocShared0,
system.deallocShared, system.reallocShared.
Slicing as implemented by the system module now supports splicing.
Added explicit channels for thread communication.
Added matchers module for email address etc. matching.
Added strutils.unindent, strutils.countLines,
strutils.replaceWord.
Added system.slurp for easy resource embedding.
Added system.running for threads.
Added system.programResult.
Added xmltree.innerText.
Added os.isAbsolute, os.dynLibFormat, os.isRootDir,
os.parentDirs.
Added parseutils.interpolatedFragments.
Added macros.treeRepr, macros.lispRepr, macros.dumpTree,
macros.dumpLisp, macros.parseExpr, macros.parseStmt,
macros.getAst.
Added locks core module for more flexible locking support.
Added irc module.
Added ftpclient module.
Added memfiles module.
Added subexes module.
Added critbits module.
Added asyncio module.
Added actors module.
Added algorithm module for generic sort, reverse etc. operations.
Added osproc.startCmd, osproc.execCmdEx.
The osproc module now uses posix_spawn instead of fork
and exec on Posix systems. Define the symbol useFork to revert to
the old implementation.
Added intsets.assign.
Added system.astToStr and system.rand, system.doAssert.
Added system.pairs for built-in types like arrays and strings.

File: jekyll/_posts/2012-09-23-version-090-released.md

title: "Version 0.9.0 released" author: Andreas Rumpf

Summary

Unsigned integers have been added.
The integer type promotion rules changed.
The template and macro system evolved.
Closures have been implemented.
Term rewriting macros have been implemented.
First steps to unify expressions and statements have been taken.
Symbol lookup rules in generics have become stricter to catch more errors.

Bugfixes

Fixed a bug where the compiler would "optimize away" valid constant parts of
a string concatenation.
Fixed a bug concerning implicit type conversions in case statements.
Fixed a serious code generation bug that caused algorithm.sort to
produce segmentation faults.
Fixed ambiguity in recvLine which meant that receiving \r\L was
indistinguishable from disconnections.
Many more bugfixes, too many to list them all.

Library Additions

Added the (already existing) module htmlgen to the documentation.
Added the (already existing) module cookies to the documentation.
Added system.shallow that can be used to speed up string and sequence
assignments.
Added system.eval that can execute an anonymous block of code at
compile time as if was a macro.
Added system.staticExec and system.gorge for compile-time execution
of external programs.
Added system.staticRead as a synonym for system.slurp.
Added macros.emit that can emit an arbitrary computed string as nimrod
code during compilation.
Added strutils.parseEnum.
Added json.% constructor operator.
The stdlib can now be avoided to a point where C code generation for 16bit
micro controllers is feasible.
Added module oids.
Added module endians.
Added a new OpenGL wrapper that supports OpenGL up to version 4.2.
Added a wrapper for libsvm.
Added a wrapper for mongodb.
Added terminal.isatty.
Added an overload for system.items that can be used to iterate over the
values of an enum.
Added system.TInteger and system.TNumber type classes matching
any of the corresponding types available in Nimrod.
Added system.clamp to limit a value within an interval [a, b].
Added strutils.continuesWith.
Added system.getStackTrace.
Added system.|| for parallel for loop support.
The GC supports (soft) realtime systems via GC_setMaxPause
and GC_step procs.
The sockets module now supports ssl through the OpenSSL library, recvLine
is now much more efficient thanks to the newly implemented sockets buffering.
The httpclient module now supports ssl/tls.
Added times.format as well as many other utility functions
for managing time.
Added system.@ for converting an openarray to a seq (it used to
only support fixed length arrays).
Added system.compiles which can be used to check whether a type supports
some operation.
Added strutils.format, subexes.format which use the
new varargs type.
Added module fsmonitor.

Changes affecting backwards compatibility

On Windows filenames and paths are supposed to be in UTF-8.
The system, os, osproc and memfiles modules use the wide
string versions of the WinAPI. Use the -d:useWinAnsi switch to revert
back to the old behaviour which uses the Ansi string versions.
static, do, interface and mixin are now keywords.
Templates now participate in overloading resolution which can break code that
uses templates in subtle ways. Use the new immediate pragma for templates
to get a template of old behaviour.
There is now a proper distinction in the type system between expr and
PNimrodNode which unfortunately breaks the old macro system.
pegs.@ has been renamed to pegs.!* and pegs.@@ has been renamed
to pegs.!*\ as @ operators now have different precedence.
The type proc (without any params or return type) is now considered a
type class matching all proc types. Use proc () to get the old meaning
denoting a proc expecing no arguments and returning no value.
Deprecated system.GC_setStrategy.
re.findAll and pegs.findAll don't return captures anymore but
matching substrings.
RTTI and thus the marshall module don't contain the proper field names
of tuples anymore. This had to be changed as the old behaviour never
produced consistent results.
Deprecated the ssl module.
Deprecated nimrod pretty as it never worked good enough and has some
inherent problems.
The integer promotion rules changed; the compiler is now less picky in some
situations and more picky in other situations: In particular implicit
conversions from int to int32 are now forbidden.
system.byte is now an alias for uint8; it used to be an alias
to int8.
bind expressions in templates are not properly supported anymore. Use
the declarative bind statement instead.
The default calling convention for a procedural type is now closure,
for procs it remains nimcall (which is compatible to closure).
Activate the warning ImplicitClosure to make the compiler list the
occurrences of proc types which are affected.
The Nimrod type system now distinguishes openarray from varargs.
Templates are now hygienic. Use the dirty pragma to get the old
behaviour.
Objects that have no ancestor are now implicitly final. Use
the inheritable pragma to introduce new object roots apart
from TObject.
Macros now receive parameters like templates do; use the callsite builtin
to gain access to the invocation AST.
Symbol lookup rules in generics have become stricter to catch more errors.

Compiler Additions

Win64 is now an officially supported target.
The Nimrod compiler works on BSD again, but has some issues
as os.getAppFilename and os.getAppDir cannot work reliably on BSD.
The compiler can detect and evaluate calls that can be evaluated at compile
time for optimization purposes with the --implicitStatic command line
option or pragma.
The compiler now generates marker procs that the GC can use instead of RTTI.
This speeds up the GC quite a bit.
The compiler now includes a new advanced documentation generator
via the doc2 command. This new generator uses all of the semantic passes
of the compiler and can thus generate documentation for symbols hiding in
macros.
The compiler now supports the dynlib pragma for variables.
The compiler now supports bycopy and byref pragmas that affect how
objects/tuples are passed.
The embedded profiler became a stack trace profiler and has been documented.

Language Additions

Added explicit static sections for enforced compile time evaluation.
Added an alternative notation for lambdas with do.
addr is now treated like a prefix operator syntactically.
Added global pragma that can be used to introduce new global variables
from within procs.
when expressions are now allowed just like if expressions.
The precedence for operators starting with @ is different now
allowing for sigil-like operators.
Stand-alone finally and except blocks are now supported.
Macros and templates can now be invoked as pragmas.
The apostrophe in type suffixes for numerical literals is now optional.
Unsigned integer types have been added.
The integer promotion rules changed.
Nimrod now tracks proper intervals for range over some built-in operators.
In parameter lists a semicolon instead of a comma can be used to improve
readability: proc divmod(a, b: int; resA, resB: var int).
A semicolon can now be used to have multiple simple statements on a single
line: inc i; inc j.
bind supports overloaded symbols and operators.
A distinct type can now borrow from generic procs.
Added the pragmas gensym, inject and dirty for hygiene
in templates.
Comments can be continued with a backslash continuation character so that
comment pieces don't have to align on the same column.
Enums can be annotated with pure so that their field names do not pollute
the current scope.
A proc body can consist of an expression that has a type. This is rewritten
to result = expression then.
Term rewriting macros (see
trmacros)
have been implemented but are still in alpha.

File: jekyll/_posts/2013-05-20-version-092-released.md

title: "Version 0.9.2 released" author: Dominik Picheta

We are pleased to announce that version 0.9.2 of the Nimrod compiler has been
released. This release has attracted by far the most contributions in comparison
to any other release.

This release brings with it many new features and bug fixes, a list of which
can be seen later. One of the major new features is the effect system together
with exception tracking which allows for checked exceptions and more,
for further details check out the manual .
Another major new feature is the introduction of statement list expressions,
more details on these can be found here.
The ability to exclude symbols from modules has also been
implemented, this feature can be used like so: import module except symbol.

Thanks to all contributors!

Bugfixes

The old GC never collected cycles correctly. Fixed but it can cause
performance regressions. However you can deactivate the cycle collector
with GC_disableMarkAndSweep and run it explicitly at an appropriate time
or not at all. There is also a new GC you can activate
with --gc:markAndSweep which does not have this problem but is slower in
general and has no realtime guarantees.
cast for floating point types now does the bitcast as specified in the
manual. This breaks code that erroneously uses cast to convert different
floating point values.
SCGI module's performance has been improved greatly, it will no longer block
on many concurrent requests.
In total fixed over 70 github issues and merged over 60 pull requests.

Library Additions

There is a new experimental mark&sweep GC which can be faster (or much
slower) than the default GC. Enable with --gc:markAndSweep.
Added system.onRaise to support a condition system.
Added system.locals that provides access to a proc's locals.
Added macros.quote for AST quasi-quoting.
Added system.unsafeNew to support hacky variable length objects.
system.fields and system.fieldPairs support object too; they
used to only support tuples.
Added system.CurrentSourcePath returning the full file-system path of
the current source file.
The macros module now contains lots of useful helpers for building up
abstract syntax trees.

Changes affecting backwards compatibility

shared is a keyword now.
Deprecated sockets.recvLine and asyncio.recvLine, added
readLine instead.
The way indentation is handled in the parser changed significantly. However,
this affects very little (if any) real world code.
The expression/statement unification has been implemented. Again this
only affects edge cases and no known real world code.
Changed the async interface of the scgi module.
WideStrings are now garbage collected like other string types.

Compiler Additions

The doc2 command does not generate output for the whole project anymore.
Use the new --project switch to enable this behaviour.
The compiler can now warn about shadowed local variables. However, this needs
to be turned on explicitly via --warning[ShadowIdent]:on.
The compiler now supports almost every pragma in a push pragma.
Generic converters have been implemented.
Added a highly experimental noforward pragma enabling a special
compilation mode that largely eliminates the need for forward declarations.

Language Additions

case expressions are now supported.
Table constructors now mimic more closely the syntax of the case
statement.
Nimrod can now infer the return type of a proc from its body.
Added a mixin declaration to affect symbol binding rules in generics.
Exception tracking has been added and the doc2 command annotates possible
exceptions for you.
User defined effects ("tags") tracking has been added and the doc2
command annotates possible tags for you.
Types can be annotated with the new syntax not nil to explicitly state
that nil is not allowed. However currently the compiler performs no
advanced static checking for this; for now it's merely for documentation
purposes.
An export statement has been added to the language: It can be used for
symbol forwarding so client modules don't have to import a module's
dependencies explicitly.
Overloading based on ASTs has been implemented.
Generics are now supported for multi methods.
Objects can be initialized via an object constructor expression.
There is a new syntactic construct (;) unifying expressions and
statements.
You can now use from module import nil if you want to import the module
but want to enforce fully qualified access to every symbol in module.

Notes for the future

The scope rules of if statements will change in 0.9.4. This affects the
=~ pegs/re templates.
The sockets module will become a low-level wrapper of OS-specific socket
functions. All the high-level features of the current sockets module
will be moved to a network module.

File: jekyll/_posts/2014-01-12-andreas-rumpfs-talk.md

title: "Andreas Rumpf's talk on Nimrod at Strange Loop 2013 is now online" author: Dominik Picheta

Andreas Rumpf presented Nimrod: A New Approach to Metaprogramming at
Strange Loop 2013.
The video and slides
of the talk are now available.

File: jekyll/_posts/2014-02-11-nimrod-features-in-dr-dobbs-journal.md

title: "Nimrod Featured in Dr. Dobb's Journal" author: Dominik Picheta

Nimrod has been featured
as the cover story in the February 2014 issue of Dr. Dobb's Journal.

File: jekyll/_posts/2014-04-21-version-094-released.md

title: "Version 0.9.4 released" author: Dominik Picheta

The Nimrod development community is proud to announce the release of version
0.9.4 of the Nimrod compiler and tools. Note: This release has to be
considered beta quality! Lots of new features have been implemented but
unfortunately some do not fulfill our quality standards yet.

Prebuilt binaries and instructions for building from source are available
on the [download page]({{ site.baseurl }}/install.html).

This release includes about
1400 changes
in total including various bug
fixes, new languages features and standard library additions and improvements.
This release brings with it support for user-defined type classes, a brand
new VM for executing Nimrod code at compile-time and new symbol binding
rules for clean templates.

It also introduces support for the brand new
Babel package manager which
has itself seen its first release recently. Many of the wrappers that were
present in the standard library have been moved to separate repositories
and should now be installed using Babel.

Apart from that a new experimental Asynchronous IO API has been added via
the asyncdispatch and asyncnet modules. The net and rawsockets
modules have also been added and they will likely replace the sockets
module in the next release. The Asynchronous IO API has been designed to
take advantage of Linux's epoll and Windows' IOCP APIs, support for BSD's
kqueue has not been implemented yet but will be in the future.
The Asynchronous IO API provides both
a callback interface and an interface which allows you to write code as you
would if you were writing synchronous code. The latter is done through
the use of an await macro which behaves similar to C#'s await. The
following is a very simple chat server demonstrating Nimrod's new async
capabilities.

nim

import asyncnet, asyncdispatch

var clients: seq[PAsyncSocket] = @[]

proc processClient(client: PAsyncSocket) {.async.} =
  while true:
    let line = await client.recvLine()
    for c in clients:
      await c.send(line & "\c\L")

proc serve() {.async.} =
  var server = newAsyncSocket()
  server.bindAddr(TPort(12345))
  server.listen()

  while true:
    let client = await server.accept()
    clients.add client

    processClient(client)

serve()
runForever()

Note that this feature has been implemented with Nimrod's macro system and so
await and async are no keywords.

Syntactic sugar for anonymous procedures has also been introduced. It too has
been implemented as a macro. The following shows some simple usage of the new
syntax:

nim

import future

var s = @[1, 2, 3, 4, 5]
echo(s.map((x: int) => x * 5))

A list of changes follows, for a comprehensive list of changes take a look
here.

Library Additions

Added macros.genSym builtin for AST generation.
Added macros.newLit procs for easier AST generation.
Added module logging.
Added module asyncdispatch.
Added module asyncnet.
Added module net.
Added module rawsockets.
Added module selectors.
Added module asynchttpserver.
Added support for the new asynchronous IO in the httpclient module.
Added a Python-inspired future module that features upcoming additions
to the system module.

Changes affecting backwards compatibility

The scoping rules for the if statement changed for better interaction
with the new syntactic construct (;).
OSError family of procedures has been deprecated. Procedures with the same
name but which take different parameters have been introduced. These procs now
require an error code to be passed to them. This error code can be retrieved
using the new OSLastError proc.
os.parentDir now returns "" if there is no parent dir.
In CGI scripts stacktraces are shown to the user only
if cgi.setStackTraceStdout is used.
The symbol binding rules for clean templates changed: bind for any
symbol that's not a parameter is now the default. mixin can be used
to require instantiation scope for a symbol.
quoteIfContainsWhite now escapes argument in such way that it can be safely
passed to shell, instead of just adding double quotes.
macros.dumpTree and macros.dumpLisp have been made immediate,
dumpTreeImm and dumpLispImm are now deprecated.
The nil statement has been deprecated, use an empty discard instead.
sockets.select now prunes sockets that are not ready from the list
of sockets given to it.
The noStackFrame pragma has been renamed to asmNoStackFrame to
ensure you only use it when you know what you're doing.
Many of the wrappers that were present in the standard library have been
moved to separate repositories and should now be installed using Babel.

Compiler Additions

The compiler can now warn about "uninitialized" variables. (There are no
real uninitialized variables in Nimrod as they are initialized to binary
zero). Activate via {.warning[Uninit]:on.}.
The compiler now enforces the not nil constraint.
The compiler now supports a codegenDecl pragma for even more control
over the generated code.
The compiler now supports a computedGoto pragma to support very fast
dispatching for interpreters and the like.
The old evaluation engine has been replaced by a proper register based
virtual machine. This fixes numerous bugs for nimrod i and for macro
evaluation.
--gc:none produces warnings when code uses the GC.
A union pragma for better C interoperability is now supported.
A packed pragma to control the memory packing/alignment of fields in
an object.
Arrays can be annotated to be unchecked for easier low level
manipulations of memory.
Support for the new Babel package manager.

Language Additions

Arrays can now be declared with a single integer literal N instead of a
range; the range is then 0..N-1.
Added requiresInit pragma to enforce explicit initialization.
Exported templates are allowed to access hidden fields.
The using statement enables you to more easily author domain-specific
languages and libraries providing OOP-like syntactic sugar.
Added the possibility to override various dot operators in order to handle
calls to missing procs and reads from undeclared fields at compile-time.
The overload resolution now supports static[T] params that must be
evaluable at compile-time.
Support for user-defined type classes has been added.
The command syntax is supported in a lot more contexts.
Anonymous iterators are now supported and iterators can capture variables
of an outer proc.
The experimental strongSpaces parsing mode has been implemented.
You can annotate pointer types with regions for increased type safety.
Added support for the builtin spawn for easy thread pool usage.

Tools improvements

c2nim can deal with a subset of C++. Use the --cpp command line option
to activate.

File: jekyll/_posts/2014-10-19-version-096-released.md

title: "Version 0.9.6 released" author: Andreas Rumpf

Note: 0.9.6 is the last release of Nimrod. The language is being renamed to
Nim. Nim slightly breaks compatibility.

This is a maintenance release. The upcoming 0.10.0 release has
the new features and exciting developments.

Changes affecting backwards compatibility

spawn now uses an elaborate self-adapting thread pool and as such
has been moved into its own module. So to use it, you now have to import
threadpool.
The symbol binding rules in generics changed: bar in foo.bar is
now considered for implicit early binding.
c2nim moved into its own repository and is now a Babel package.
pas2nim moved into its own repository and is now a Babel package.
system.$ for floating point types now produces a human friendly string
representation.
uri.TUrl as well as the parseurl module are now deprecated in favour
of the new TUri type in the uri module.
The destructor pragma has been deprecated. Use the override pragma
instead. The destructor's name has to be destroy now.
lambda is not a keyword anymore.
system.defined has been split into system.defined and system.declared.
You have to use --symbol to declare new conditional symbols that can be
set via --define.
--threadanalysis:on is now the default. To make your program compile
you can disable it but this is only a temporary solution as this option
will disappear soon!

Compiler improvements

Multi method dispatching performance has been improved by a factor of 10x for
pathological cases.

Language Additions

This version introduces the deprecated pragma statement that is used
to handle the upcoming massive amount of symbol renames.
spawn can now wrap proc that has a return value. It then returns a data
flow variable of the wrapped return type.

Library Additions

Added module cpuinfo.
Added module threadpool.
sequtils.distnct has been renamed to sequtils.deduplicate.
Added algorithm.reversed
Added uri.combine and uri.parseUri.
Some sockets procedures now support a SafeDisconn flag which causes
them to handle disconnection errors and not raise them.

File: jekyll/_posts/2014-12-09-new-website.md

title: "New website design!" author: Andreas Rumpf

A brand new website including an improved forum is now live.
All thanks go to Philip Witte and
Dominik Picheta, Philip Witte for the design of the website (together with
the logo) as well as the HTML and CSS code for his template, and Dominik Picheta
for integrating Philip's design with Nim's forum. We're sure you will
agree that Philip's design is beautiful.

File: jekyll/_posts/2014-12-29-version-0102-released.md

title: "Version 0.10.2 released" author: Dominik Picheta

This release marks the completion of a very important change to the project:
the official renaming from Nimrod to Nim. Version 0.10.2 contains many language
changes, some of which may break your existing code. For your convenience, we
added a new tool called nimfix that will help you convert your
existing projects so that it works with the latest version of the compiler.

Progress towards version 1.0

Although Nim is still pre-1.0, we were able to keep the number of breaking
changes to a minimum so far. Starting with version 1.0, we will not introduce
any breaking changes between major release versions.
One of Nim's goals is to ensure that the compiler is as efficient as possible.
Take a look at the
latest benchmarks,
which show that Nim is consistently near
the top and already nearly as fast as C and C++. Recent developments, such as
the new asyncdispatch module will allow you to write efficient web server
applications using non-blocking code. Nim now also has a built-in thread pool
for lightweight threading through the use of spawn.

The unpopular "T" and "P" prefixes on types have been deprecated. Nim also
became more expressive by weakening the distinction between statements and
expressions. We also added a new and searchable forum, a new website, and our
documentation generator docgen has seen major improvements. Many thanks to
Nick Greenfield for the much more beautiful documentation!

What's left to be done

The 1.0 release is actually very close. Apart from bug fixes, there are
two major features missing or incomplete:

static[T] needs to be defined precisely and the bugs in the
implementation need to be fixed.
Overloading of the assignment operator is required for some generic
containers and needs to be implemented.

This means that fancy matrix libraries will finally start to work, which used
to be a major point of pain in the language.

Nimble and other Nim tools

Outside of the language and the compiler itself many Nim tools have seen
considerable improvements.

Babel the Nim package manager has been renamed to Nimble. Nimble's purpose
is the installation of packages containing libraries and/or applications
written in Nim.
Even though Nimble is still very young it already is very
functional. It can install packages by name, it does so by accessing a
packages repository which is hosted on a GitHub repo. Packages can also be
installed via a Git repo URL or Mercurial repo URL. The package repository
is searchable through Nimble. Anyone is free to add their own packages to
the package repository by forking the
nim-lang/packages repo and creating
a pull request. Nimble is fully cross-platform and should be fully functional
on all major operating systems.
It is of course completely written in Nim.

Changelog

Changes affecting backwards compatibility

The language has been renamed from Nimrod to Nim. The name of the
compiler changed from nimrod to nim too.
system.fileHandle has been renamed to system.getFileHandle to
prevent name conflicts with the new type FileHandle.
Comments are now not part of the AST anymore, as such you cannot use them
in place of discard.
Large parts of the stdlib got rid of the T/P type prefixes. Instead most
types now simply start with an uppercased letter. The
so called "partial case sensitivity" rule is now active allowing for code
like var foo: Foo in more contexts.
String case (or any non-ordinal case) statements
without 'else' are deprecated.
Recursive tuple types are not allowed anymore. Use object instead.
The PEGS module returns nil instead of "" when an optional capture
fails to match.
The re module returns nil instead of "" when an optional capture
fails to match.
The "symmetric set difference" operator (-+-) never worked and has been
removed.
defer is a keyword now.
func is a keyword now.
The using language feature now needs to be activated via the new
{.experimental.} pragma that enables experimental language features.
Destructors are now officially experimental.
Standalone except and finally statements are deprecated now.
The standalone finally can be replaced with defer,
standalone except requires an explicit try.
Operators ending in > are considered as "arrow like" and have their
own priority level and are right associative. This means that
the => and -> operators from the
future module
work better.
Field names in tuples are now ignored for type comparisons. This allows
for greater interoperability between different modules.
Statement lists are not converted to an implicit do block anymore. This
means the confusing nnkDo nodes when working with macros are gone for
good.

Language Additions

The new concurrency model has been implemented including locks sections,
lock levels and object field guards.
The parallel statement has been implemented.
deepCopy has been added to the language.
The builtin procCall can be used to get super-like functionality
for multi methods.
There is a new pragma {.experimental.} that enables experimental
language features per module, or you can enable these features on a global
level with the --experimental command line option.

Compiler Additions

The compiler now supports mixed Objective C / C++ / C code generation:
The modules that use importCpp or importObjc are compiled to C++
or Objective C code, any other module is compiled to C code. This
improves interoperability.
There is a new parallel statement for safe fork&join parallel computing.
guard and lock pragmas have been implemented to support safer
concurrent programming.
The following procs are now available at compile-time::

math.sqrt, math.ln, math.log10, math.log2, math.exp, math.round,
math.arccos, math.arcsin, math.arctan, math.arctan2, math.cos,
math.cosh, math.hypot, math.sinh, math.sin, math.tan, math.tanh,
math.pow, math.trunc, math.floor, math.ceil, math.fmod,
os.getEnv, os.existsEnv, os.dirExists, os.fileExists,
system.writeFile
Two backticks now produce a single backtick within an emit or asm
statement.
There is a new tool, nimfix to help you in updating your
code from Nimrod to Nim.
The compiler's output has been prettified.

Library Additions

Added module fenv to control the handling of floating-point rounding and
exceptions (overflow, division by zero, etc.).
system.setupForeignThreadGc can be used for better interaction with
foreign libraries that create threads and run a Nim callback from these
foreign threads.
List comprehensions have been implemented as a macro in the future
module.
The new Async module (asyncnet) now supports SSL.
The smtp module now has an async implementation.
Added module asyncfile which implements asynchronous file reading
and writing.
osproc.kill has been added.
asyncnet and asynchttpserver now support SO_REUSEADDR.

Bugfixes

nil and NULL are now preserved between Nim and databases in the
db_* modules.
Fixed issue with OS module in non-unicode mode on Windows.
Fixed issue with x.low
(#1366).
Fixed tuple unpacking issue inside closure iterators
(#1067).
Fixed ENDB compilation issues.
Many asynchttpserver fixes.
Macros can now keep global state across macro calls
(#903).
osproc fixes on Windows.
osproc.terminate fixed.
Improvements to exception handling in async procedures.
(#1487).
try now works at compile-time.
Fixes T = ref T to be an illegal recursive type.
Self imports are now disallowed.
Improved effect inference.
Fixes for the math module on Windows.
User defined pragmas will now work for generics that have
been instantiated in different modules.
Fixed queue exhaustion bug.
Many, many more.

File: jekyll/_posts/2015-04-30-version-0110-released.md

title: "Version 0.11.0 released" author: Dominik Picheta

With this release we are one step closer to reaching version 1.0 and by
extension the persistence of the Nim specification. As mentioned in the
previous release notes, starting with version 1.0, we will not be introducing
any more breaking changes to Nim.

The language itself is very close to 1.0, the primary area that requires
more work is the standard library.

Take a look at the download page for binaries (Windows-only)
and 0.11.0 snapshots of the source code. The Windows installer now also
includes Aporia,
Nimble and other useful tools to get
you started with Nim.

What's left to be done

The 1.0 release is expected by the end of this year. Rumors say it will be in
summer 2015. What's left:

Bug fixes, bug fixes, bug fixes, in particular:
- The remaining bugs of the lambda lifting pass that is responsible to enable
  closures and closure iterators need to be fixed.
- concept needs to be refined, a nice name for the feature is not enough.
- Destructors need to be refined.
- static[T] needs to be fixed.
- Finish the implementation of the 'parallel' statement.
immediate templates and macros will be deprecated as these will soon be
completely unnecessary, instead the typed or untyped metatypes can
be used.
More of the standard library should be moved to Nimble packages and what's
left should use the features we have for concurrency and parallelism.

Changes affecting backwards compatibility

Parameter names are finally properly gensym'ed. This can break
templates though that used to rely on the fact that they are not.
(Bug #1915.) This means this doesn't compile anymore:
nim
```
template doIt(body: stmt) {.immediate.} =
  # this used to inject the 'str' parameter:
  proc res(str: string) =
    body

doIt:
  echo str # Error: undeclared identifier: 'str'
```
This used to inject the str parameter into the scope of the body.
Declare the doIt template as immediate, dirty to get the old
behaviour.
Tuple field names are not ignored anymore, this caused too many problems
in practice so now the behaviour is as it was for version 0.9.6: If field
names exist for the tuple type, they are checked.
logging.level and logging.handlers are no longer exported.
addHandler, getHandlers, setLogFilter and getLogFilter
should be used instead.
nim idetools has been replaced by a separate
tool nimsuggest.
arrow like operators are not right associative anymore and are required
to end with either ->, ~> or
=>, not just >. Examples of operators still considered arrow like:
->, ==>, +=>. On the other hand, the following operators are now
considered regular operators again: |>, -+>, etc.
Typeless parameters are now only allowed in templates and macros. The old
way turned out to be too error-prone.
The 'addr' and 'type' operators are now parsed as unary function
application. This means type(x).name is now parsed as (type(x)).name
and not as type((x).name). Note that this also affects the AST
structure; for immediate macro parameters nkCall('addr', 'x') is
produced instead of nkAddr('x').
concept is now a keyword and is used instead of generic.
The inc, dec, +=, -= builtins now produce OverflowError
exceptions. This means code like the following:
nim
```
var x = low(T)
while x <= high(T):
  echo x
  inc x
```
Needs to be replaced by something like this:
nim
```
var x = low(T).int
while x <= high(T).int:
  echo x.T
  inc x
```
Negative indexing for slicing does not work anymore! Instead
of a[0.. -1] you can
use a[0.. ^1]. This also works with accessing a single
element a[^1]. Note that we cannot detect this reliably as it is
determined at runtime whether negative indexing is used!
a[0.. -1] now produces the empty string/sequence.
The compiler now warns about code like foo +=1 which uses inconsistent
spacing around binary operators. Later versions of the language will parse
these as unary operators instead so that echo $foo finally can do what
people expect it to do.
system.untyped and system.typed have been introduced as aliases
for expr and stmt. The new names capture the semantics much better
and most likely expr and stmt will be deprecated in favor of the
new names.
The split method in module re has changed. It now handles the case
of matches having a length of 0, and empty strings being yielded from the
iterator. A notable change might be that a pattern being matched at the
beginning and end of a string, will result in an empty string being produced
at the start and the end of the iterator.
The compiler and nimsuggest now count columns starting with 1, not 0 for
consistency with the rest of the world.

Language Additions

For empty case object branches discard can finally be used instead
of nil.
Automatic dereferencing is now done for the first argument of a routine
call if overloading resolution produces no match otherwise. This feature
has to be enabled with
the experimental pragma.
Objects that do not use inheritance nor case can be put into const
sections. This means that finally this is possible and produces rather
nice code:
nim
```
import tables

const
  foo = {"ah": "finally", "this": "is", "possible.": "nice!"}.toTable()
```

Ordinary parameters can follow after a varargs parameter. This means the
following is finally accepted by the compiler:

nim

template takesBlock(a, b: int, x: varargs[expr]; blck: stmt) =
  blck
  echo a, b

takesBlock 1, 2, "some", 0.90, "random stuff":
  echo "yay"

Overloading by 'var T' is now finally possible:

nim

proc varOrConst(x: var int) = echo "var"
proc varOrConst(x: int) = echo "const"

var x: int
varOrConst(x) # "var"
varOrConst(45) # "const"

Array and seq indexing can now use the builtin ^ operator to access
things from backwards: a[^1] is like Python's a[-1].
A first version of the specification and implementation of the overloading
of the assignment operator has arrived!
system.len for strings and sequences now returns 0 for nil.
A single underscore can now be used to discard values when unpacking tuples:
nim
```
let (path, _, _) = os.splitFile("path/file.ext")
```
marshal.$$ and marshal.to can be executed at compile-time.
Interoperability with C++ improved tremendously; C++'s templates and
operators can be wrapped directly. See
this
for more information.
macros.getType can be used to query an AST's type at compile-time. This
enables more powerful macros, for instance currying can now be done with
a macro.

Library additions

reversed proc added to the unicode module.
Added multipart param to httpclient's post and postContent together
with a newMultipartData proc.
Added %* operator for JSON.
The compiler is now available as Nimble package for c2nim.
Added ..^ and ..< templates to system so that the rather annoying
space between .. < and .. ^ is not necessary anymore.
Added system.xlen for strings and sequences to get back the old len
operation that doesn't check for nil for efficiency.
Added sexp.nim to parse and generate sexp.

Bugfixes

Fixed internal compiler error when using char() in an echo call
(#1788).
Fixed Windows cross-compilation on Linux.
Overload resolution now works for types distinguished only by a
static[int] param
(#1056).
Other fixes relating to generic types and static params.
Fixed some compiler crashes with unnamed tuples
(#1774).
Fixed channels.tryRecv blocking
(#1816).
Fixed generic instantiation errors with typedesc
(#419).
Fixed generic regression where the compiler no longer detected constant
expressions properly (#544).
Fixed internal error with generic proc using static[T] in a specific
way (#1049).
More fixes relating to generics (#1820,
#1050,
#1859,
#1858).
Fixed httpclient to properly encode queries.
Many fixes to the uri module.
Async sockets are now closed on error.
Fixes to httpclient's handling of multipart data.
Fixed GC segfaults with asynchronous sockets
(#1796).
Added more versions to openssl's DLL version list
(076f993).
Fixed shallow copy in iterators being broken
(#1803).
nil can now be inserted into tables with the db_sqlite module
(#1866).
Fixed "Incorrect assembler generated"
(#1907)
Fixed "Expression templates that define macros are unusable in some contexts"
(#1903)
Fixed "a second level generic subclass causes the compiler to crash"
(#1919)
Fixed "nim 0.10.2 generates invalid AsyncHttpClient C code for MSVC "
(#1901)
Fixed "1 shl n produces wrong C code"
(#1928)
Fixed "Internal error on tuple yield"
(#1838)
Fixed "ICE with template"
(#1915)
Fixed "include the tool directory in the installer as it is required by koch"
(#1947)
Fixed "Can't compile if file location contains spaces on Windows"
(#1955)
Fixed "List comprehension macro only supports infix checks as guards"
(#1920)
Fixed "wrong field names of compatible tuples in generic types"
(#1910)
Fixed "Macros within templates no longer work as expected"
(#1944)
Fixed "Compiling for Standalone AVR broken in 0.10.2"
(#1964)
Fixed "Compiling for Standalone AVR broken in 0.10.2"
(#1964)
Fixed "Code generation for mitems with tuple elements"
(#1833)
Fixed "httpclient.HttpMethod should not be an enum"
(#1962)
Fixed "terminal / eraseScreen() throws an OverflowError"
(#1906)
Fixed "setControlCHook(nil) disables registered quit procs"
(#1546)
Fixed "Unexpected idetools behaviour"
(#325)
Fixed "Unused lifted lambda does not compile"
(#1642)
Fixed "'low' and 'high' don't work with cstring asguments"
(#2030)
Fixed "Converting to int does not round in JS backend"
(#1959)
Fixed "Internal error genRecordField 2 when adding region to pointer."
(#2039)
Fixed "Macros fail to compile when compiled with --os:standalone"
(#2041)
Fixed "Reading from {.compileTime.} variables can cause code generation to fail"
(#2022)
Fixed "Passing overloaded symbols to templates fails inside generic procedures"
(#1988)
Fixed "Compiling iterator with object assignment in release mode causes "var not init""
(#2023)
Fixed "calling a large number of macros doing some computation fails"
(#1989)
Fixed "Can't get Koch to install nim under Windows"
(#2061)
Fixed "Template with two stmt parameters segfaults compiler"
(#2057)
Fixed "noSideEffect not affected by echo"
(#2011)
Fixed "Compiling with the cpp backend ignores --passc"
(#1601)
Fixed "Put untyped procedure parameters behind the experimental pragma"
(#1956)
Fixed "generic regression"
(#2073)
Fixed "generic regression"
(#2073)
Fixed "Regression in template lookup with generics"
(#2004)
Fixed "GC's growObj is wrong for edge cases"
(#2070)
Fixed "Compiler internal error when creating an array out of a typeclass"
(#1131)
Fixed "GC's growObj is wrong for edge cases"
(#2070)
Fixed "Invalid Objective-C code generated when calling class method"
(#2068)
Fixed "walkDirRec Error"
(#2116)
Fixed "Typo in code causes compiler SIGSEGV in evalAtCompileTime"
(#2113)
Fixed "Regression on exportc"
(#2118)
Fixed "Error message"
(#2102)
Fixed "hint[path] = off not working in nim.cfg"
(#2103)
Fixed "compiler crashes when getting a tuple from a sequence of generic tuples"
(#2121)
Fixed "nim check hangs with when"
(#2123)
Fixed "static[T] param in nested type resolve/caching issue"
(#2125)
Fixed "repr should display \0"
(#2124)
Fixed "'nim check' never ends in case of recursive dependency "
(#2051)
Fixed "From macros: Error: unhandled exception: sons is not accessible"
(#2167)
Fixed "fieldPairs doesn't work inside templates"
(#1902)
Fixed "fields iterator misbehavior on break statement"
(#2134)
Fixed "Fix for compiler not building anymore since #c3244ef1ff"
(#2193)
Fixed "JSON parser fails in cpp output mode"
(#2199)
Fixed "macros.getType mishandles void return"
(#2211)
Fixed "Regression involving templates instantiated within generics"
(#2215)
Fixed ""Error: invalid type" for 'not nil' on generic type."
(#2216)
Fixed "--threads:on breaks async"
(#2074)
Fixed "Type mismatch not always caught, can generate bad code for C backend."
(#2169)
Fixed "Failed C compilation when storing proc to own type in object"
(#2233)
Fixed "Unknown line/column number in constant declaration type conversion error"
(#2252)
Fixed "Adding {.compile.} fails if nimcache already exists."
(#2247)
Fixed "Two different type names generated for a single type (C backend)"
(#2250)
Fixed "Ambiguous call when it should not be"
(#2229)
Fixed "Make sure we can load root urls"
(#2227)
Fixed "Failure to slice a string with an int subrange type"
(#794)
Fixed "documentation error"
(#2205)
Fixed "Code growth when using const"
(#1940)
Fixed "Instances of generic types confuse overload resolution"
(#2220)
Fixed "Compiler error when initializing sdl2's EventType"
(#2316)
Fixed "Parallel disjoint checking can't handle <, items, or arrays"
(#2287)
Fixed "Strings aren't copied in parallel loop"
(#2286)
Fixed "JavaScript compiler crash with tables"
(#2298)
Fixed "Range checker too restrictive"
(#1845)
Fixed "Failure to slice a string with an int subrange type"
(#794)
Fixed "Remind user when compiling in debug mode"
(#1868)
Fixed "Compiler user guide has jumbled options/commands."
(#1819)
Fixed "using method: 1 in a objects constructor fails when compiling"
(#1791)

File: jekyll/_posts/2015-05-04-version-0112-released.md

title: "Version 0.11.2 released" author: Andreas Rumpf

This is just a bugfix release that fixes the most pressing regressions we
introduced with version 0.11.0. The way types are computed was
changed significantly causing all sort of problems. Sorry for the
inconvenience; we grew overconfident our large test suite would prevent these
things.

File: jekyll/_posts/2015-10-16-first-nim-conference.md

title: "First Nim conference" excerpt: "Learn about the first Nim workshop in Kyiv." author: Dominik Picheta

This Autumn you have the unique opportunity to take part in the first Nim event
held in Kyiv and to meet the creator of the Nim programming language -
Andreas Rumpf. The event is hosted by Zeo Alliance and is taking place between
14-15 November 2015 in Kyiv, Ukraine.

During the workshop you will learn:

The basics of the language including its safe and unsafe subsets.
How to use Nim to develop web applications.
How Nim's meta programming capabilities make Nim the ultimate glue language,
excellent at interoperability with C++, JavaScript, Java and others.
Games in Nim and the ability to rapidly prototype without sacrificing speed.

Registration is free, but the number of places is limited. More details
can be found here.

File: jekyll/_posts/2015-10-27-version-0120-released.md

title: "Version 0.12.0 released" author: Dominik Picheta

The Nim community of developers is proud to announce the new version of the
Nim compiler. This has been a long time coming as the last release has been
made over 5 months ago!

This release includes some changes which affect backwards compatibility,
one major change is that now the hash table [] operators now raise a
KeyError exception when the key does not exist.

Some of the more exciting new features include: the ability to unpack tuples
in any assignment context, the introduction of
NimScript,
and improvements to the type inference of lambdas.

There are of course many many many bug fixes included with this release.
We are getting closer and closer to a 1.0 release and are hoping that only
a few 0.x releases will be necessary before we are happy to release version 1.0.

As always you can download the latest version of Nim from the
download page.

For a more detailed list of changes look below. Some of the upcoming breaking
changes are also documented in this forum
thread.

Changes affecting backwards compatibility

The regular expression modules, re and nre now depend on version
8.36 of PCRE. If you have an older version you may see a message similar
to could not import: pcre_free_study output when you start your
program. See this issue
for more information.
tables.[], strtabs.[], critbits.[] now raise
the KeyError exception when the key does not exist! Use the
new getOrDefault instead to get the old behaviour. Compile all your
code with -d:nimTableGet to get a listing of where your code
uses []!
The rawsockets module has been renamed to nativesockets to avoid
confusion with TCP/IP raw sockets, so newNativeSocket should be used
instead of newRawSocket.
The miliseconds property of times.TimeInterval is now milliseconds.
Code accessing that property is deprecated and code using miliseconds
during object initialization or as a named parameter of initInterval()
will need to be updated.
std.logging functions no longer do formatting and semantically treat
their arguments just like echo does. Affected functions: log,
debug, info, warn, error, fatal. Custom subtypes of
Logger also need to be adjusted accordingly.
Floating point numbers can now look like 2d (float64)
and 2f (float32) which means imports like import scene/2d/sprite
do not work anymore. Instead quotes have to be
used: import "scene/2d/sprite". The former code never was valid Nim.
The Windows API wrapper (windows.nim) is now not part of the official
distribution anymore. Instead use the oldwinapi Nimble package.
There is now a clear distinction between --os:standalone
and --gc:none. So if you use --os:standalone ensure you also use
--gc:none. --os:standalone without --gc:none is now a version
that doesn't depend on any OS but includes the GC. However this version
is currently untested!
All procedures which construct a Socket/AsyncSocket now need to
specify the socket domain, type and protocol. The param name
typ: SockType (in newSocket/newAsyncSocket procs) was also
renamed to sockType. The param af in the connect procs was
removed. This affects asyncnet, asyncdispatch, net, and
rawsockets.
varargs[typed] and varargs[untyped] have been refined and now work
as expected. However varargs[untyped] is not an alias anymore for
varargs[expr]. So if your code breaks for varargs[untyped], use
varargs[expr] instead. The same applies to varargs[typed] vs
varargs[stmt].
sequtils.delete doesn't take confusing default arguments anymore.
system.free was an error-prone alias to system.dealloc and has
been removed.
macros.high never worked and the manual says high cannot be
overloaded, so we removed it with no deprecation cycle.
To use the parallel statement you now have to
use the --experimental mode.
Toplevel procs of calling convention closure never worked reliably
and are now deprecated and will be removed from the language. Instead you
have to insert type conversions
like (proc (a, b: int) {.closure.})(myToplevelProc) if necessary.
The modules libffi, sdl, windows, zipfiles, libzip,
zlib, zzip, dialogs, expat, graphics, libcurl,
sphinx have been moved out of the stdlib and are Nimble packages now.
The constant fights between 32 and 64 bit DLLs on Windows have been put to
an end: The standard distribution now ships with 32 and 64 bit versions
of all the DLLs the standard library needs. This means that the following
DLLs are now split into 32 and 64 versions:
- pcre.dll: Split into pcre32.dll and pcre64.dll.
- pdcurses.dll: Split into pdcurses32.dll and pdcurses64.dll.
- sqlite3.dll: Split into sqlite3_32.dll and sqlite3_64.dll.
- ssleay32.dll: Split into ssleay32.dll and ssleay64.dll.
- libeay32.dll: Split into libeay32.dll and libeay64.dll.
Compile with -d:nimOldDLLs to make the stdlib use the old DLL names.
Nim VM now treats objects as nkObjConstr nodes, and not nkPar nodes
as it was previously. Macros that generate nkPar nodes when object is
expected are likely to break. Macros that expect nkPar nodes to which
objects are passed are likely to break as well.
Base methods now need to be annotated with the base pragma. This makes
multi methods less error-prone to use with the effect system.
Nim's parser directive #! is now #? in order to produce no conflicts
with Unix's #!.
An implicit return type for an iterator is now deprecated. Use auto if
you want more type inference.
The type auto is now a "multi-bind" metatype, so the following compiles:
nim
```
proc f(x, y: auto): auto =
  result = $x & y

echo f(0, "abc")
```
The ftpclient module is now deprecated in favour of the
asyncftpclient module.
In sequtils.nim renamed repeat function to cycle (concatenating
a sequence by itself the given times), and also introduced repeat,
which repeats an element the given times.
The function map is moved to sequtils.nim. The inplace map version
is renamed to apply.
The template mapIt now doesn't require the result's type parameter.
Also the inplace mapIt is renamed to apply.

The compiler is now stricter with what is allowed as a case object
discriminator. The following code used to compile but was not supported
completely and so now fails:

nim

type
    DataType* {.pure.} = enum
        Char = 1,
        Int8 = 2,
        Int16 = 3,
        Int32 = 4,
        Int64 = 5,
        Float32 = 6,
        Float64 = 7

    DataSeq* = object
        case kind* : DataType
        of DataType.Char: charSeq* : seq[char]
        of DataType.Int8: int8Seq* : seq[int8]
        of DataType.Int16: int16Seq* : seq[int16]
        of DataType.Int32: int32Seq* : seq[int32]
        of DataType.Int64: int64Seq* : seq[int64]
        of DataType.Float32: float32Seq* : seq[float32]
        of DataType.Float64: float64Seq* : seq[float64]

        length* : int

Library Additions

The nre module has been added, providing a better interface to PCRE than re.
The expandSymlink proc has been added to the os module.
The tailDir proc has been added to the os module.
Define nimPinToCpu to make the threadpool use explicit thread
affinities. This can speed up or slow down the thread pool; it's up to you
to benchmark it.
strutils.formatFloat and formatBiggestFloat do not depend on the C
locale anymore and now take an optional decimalSep = '.' parameter.
Added unicode.lastRune, unicode.graphemeLen.

Compiler Additions

The compiler now supports a new configuration system based on
NimScript.
The compiler finally considers symbol binding rules in templates and
generics for overloaded [], []=, {}, {}= operators
(issue #2599).
The compiler now supports a bitsize pragma
for constructing bitfields.
Added a new --reportConceptFailures switch for better debugging of
concept related type mismatches. This can also be used to debug
system.compiles failures.

Language Additions

system.unsafeAddr can be used to access the address of a let
variable or parameter for C interoperability. Since technically this
makes parameters and let variables mutable, it is considered even more
unsafe than the ordinary addr builtin.
Added macros.getImpl that can be used to access the implementation of
a routine or a constant. This allows for example for user-defined inlining
of function calls.
Tuple unpacking finally works in a non-var/let context: (x, y) = f()
is allowed. Note that this doesn't declare x and y variables, for
this let (x, y) = f() still needs to be used.
when nimvm can now be used for compiletime versions of some code
sections. Click here for details.
Usage of the type NimNode in a proc now implicitly annotates the proc
with .compileTime. This means generics work much better for NimNode.

Bugfixes

Fixed "Compiler internal error on iterator it(T: typedesc[Base]) called with it(Child), where Child = object of Base"
(#2662)
Fixed "repr() misses base object field in 2nd level derived object"
(#2749)
Fixed "nimsuggest doesn't work more than once on the non-main file"
(#2694)
Fixed "JS Codegen. Passing arguments by var in certain cases leads to invalid JS."
(#2798)
Fixed ""check" proc in unittest.nim prevents the propagation of changes to var parameters."
(#964)
Fixed "Excessive letters in integer literals are not an error"
(#2523)
Fixed "Unicode dashes as "lisp'ish" alternative to hump and snake notation"
(#2811)
Fixed "Bad error message when trying to construct an object incorrectly"
(#2584)
Fixed "Determination of GC safety of globals is broken "
(#2854)
Fixed "v2 gc crashes compiler"
(#2687)
Fixed "Compile error using object in const array"
(#2774)
Fixed "httpclient async requests with method httpPOST isn't sending Content-Length header"
(#2884)
Fixed "Streams module not working with JS backend"
(#2148)
Fixed "Sign of certain short constants is wrong"
(#1179)
Fixed "Symlinks to directories reported as symlinks to files"
(#1985)
Fixed "64-bit literals broken on x86"
(#2909)
Fixed "import broken for certain names"
(#2904)
Fixed "Invalid UTF-8 strings in JavaScript"
(#2917)
Fixed "[JS][Codegen] Initialising object doesn't create unmentioned fields."

(#2617)
Fixed "Table returned from proc computed at compile time is missing keys:"
(#2297)
Fixed "Clarify copyright status for some files"
(#2949)
Fixed "math.nim: trigonometry: radians to degrees conversion"
(#2881)
Fixed "xoring unsigned integers yields RangeError in certain conditions"
(#2979)
Fixed "Directly checking equality between procs"
(#2985)
Fixed "Compiler crashed, but there have to be meaningful error message"
(#2974)
Fixed "repr is broken"
(#2992)
Fixed "Ipv6 devel - add IPv6 support for asyncsockets, make AF_INET6 a default"
(#2976)
Fixed "Compilation broken on windows"
(#2996)
Fixed "'u64 literal conversion compiler error"
(#2731)
Fixed "Importing 'impure' libraries while using threads causes segfaults"
(#2672)
Fixed "Uncatched exception in async procedure on raise statement"
(#3014)
Fixed "nim doc2 fails in Mac OS X due to system.nim (possibly related to #1898)"
(#3005)
Fixed "IndexError when rebuilding Nim on iteration 2"
(#3018)
Fixed "Assigning large const set to variable looses some information"
(#2880)
Fixed "Inconsistent generics behavior"
(#3022)
Fixed "Compiler breaks on float64 division"
(#3028)
Fixed "Confusing error message comparing string to nil "
(#2935)
Fixed "convert 64bit number to float on 32bit"
(#1463)
Fixed "Type redefinition and construction will break nim check"
(#3032)
Fixed "XmlParser fails on very large XML files without new lines"
(#2429)
Fixed "Error parsing arguments with whitespaces"
(#2874)
Fixed "Crash when missing one arg and used a named arg"
(#2993)
Fixed "Wrong number of arguments in assert will break nim check"
(#3044)
Fixed "Wrong const definition will break nim check"
(#3041)
Fixed "Wrong set declaration will break nim check"
(#3040)
Fixed "Compiler segfault (type section)"
(#2540)
Fixed "Segmentation fault when compiling this code"
(#3038)
Fixed "Kill nim i"
(#2633)
Fixed "Nim check will break on wrong array declaration"
(#3048)
Fixed "boolVal seems to be broken"
(#3046)
Fixed "Nim check crashes on wrong set/array declaration inside ref object"
(#3062)
Fixed "Nim check crashes on incorrect generic arg definition"
(#3051)
Fixed "Nim check crashes on iterating nonexistent var"
(#3053)
Fixed "Nim check crashes on wrong param set declaration + iteration"
(#3054)
Fixed "Wrong sharing of static_t instantations"
(#3112)
Fixed "Automatically generated proc conflicts with user-defined proc when .exportc.'ed"
(#3134)
Fixed "getTypeInfo call crashes nim"
(#3099)
Fixed "Array ptr dereference"
(#2963)
Fixed "Internal error when repr-ing a type directly"
(#3079)
Fixed "unknown type name 'TNimType' after importing typeinfo module"
(#2841)
Fixed "Can export a template twice and from inside a block"
(#1738)
Fixed "C Codegen: C Types are defined after their usage in certain cases"
(#2823)
Fixed "s.high refers to the current seq instead of the old one"
(#1832)
Fixed "Error while unmarshaling null values"
(#3149)
Fixed "Inference of static[T] in sequences"
(#3144)
Fixed "Argument named "closure" to proc inside template interfere with closure pragma"
(#3171)
Fixed "Internal error with aliasing inside template"
(#3158)
Fixed "Cardinality of sets prints unexpected value"
(#3135)
Fixed "Nim crashes on const assignment from function returning var ref object"
(#3103)
Fixed "repr cstring"
(#3080)
Fixed "Nim check crashes on wrong enum declaration"
(#3052)
Fixed "Compiler assertion when evaluating template with static[T]"
(#1858)
Fixed "Erroneous overflow in iterators when compiler built with overflowChecks enabled"
(#3140)
Fixed "Unicode dashes as "lisp'ish" alternative to hump and snake notation"
(#2811)
Fixed "Calling discardable proc from a defer is an error."
(#3185)
Fixed "Defer statement at the end of a block produces ICE"
(#3186)
Fixed "Call to createU fails to compile"
(#3193)
Fixed "VM crash when accessing array's element"
(#3192)
Fixed "Unexpected proc invoked when different modules add procs to a type from a 3rd module"
(#2664)
Fixed "Nim crashes on conditional declaration inside a template"
(#2670)
Fixed "Iterator names conflict within different scopes"
(#2752)
Fixed "VM: Cannot assign int value to ref variable"
(#1329)
Fixed "Incorrect code generated for tagged unions with enums not starting at zero"
(#3096)
Fixed "Compile time procs using forward declarations are silently ignored"
(#3066)
Fixed "re binding error in generic"
(#1965)
Fixed "os.getCreationTime is incorrect/impossible on Posix systems"
(#1058)
Fixed "Improve error message for osproc.startProcess when command does not exist"
(#2183)
Fixed "gctest segfaults with --gc:markandsweep on x86_64"
(#2305)
Fixed "Coroutine changes break compilation on unsupported architectures"
(#3245)
Fixed "Bugfix: Windows 32bit TinyCC support issue fixed"
(#3237)
Fixed "db_mysql getValue() followed by exec() causing error"
(#3220)
Fixed "xmltree.newEntity creates xnCData instead of xnEntity"
(#3282)
Fixed "Methods and modules don't work together"
(#2590)
Fixed "String slicing not working in the vm"
(#3300)
Fixed "internal error: evalOp(mTypeOf)"
(#3230)
Fixed "#! source code prefix collides with Unix Shebang"
(#2559)
Fixed "wrong codegen for constant object"
(#3195)
Fixed "Doc comments inside procs with implicit returns don't work"
(#1528)

File: jekyll/_posts/2016-01-18-oscon-conf-amsterdam.md

title: "Andreas Rumpf's talk at OSCON Amsterdam" author: Dominik Picheta

In case you have missed it, here is Andreas' Nim: An Overview talk at
OSCON Amsterdam.

File: jekyll/_posts/2016-01-18-version-0130-released.md

title: "Version 0.13.0 released" author: Dominik Picheta

Once again we are proud to announce the latest release of the Nim compiler
and related tools. This release comes just 3 months after the last
release!

A new version of Nimble which depends on this release, has also been
released. See this forum thread for
more information about the Nimble release.

This release of Nim includes over 116 bug fixes, many of which are related
to closures. The lambda lifting algorithm in the compiler has been completely
rewritten, and some changes have been made to the semantics of closures in
Nim as a result. These changes may affect backwards compatibility and are all
described in the section below.

With this release, we are one step closer to Nim version 1.0.
The 1.0 release will be a big milestone for Nim, because after that version
is released there will be no more breaking changes made to the language
or the standard library.

That being said, the next release will likely be Nim 0.14. It will focus on
improvements to the GC and concurrency. We will in particular be looking at
ways to add multi-core support to async await. Standard library improvements
are also on our roadmap but may not make it for Nim 0.14.

As always you can download the latest version of Nim from the
download page.

Happy coding!

Changes affecting backwards compatibility

macros.newLit for bool now produces false/true symbols which
actually work with the bool datatype.
When compiling to JS: Node, NodeType and Document are no longer
defined. Use the types defined in dom.nim instead.
The check x is iterator (used for instance in concepts) was always a
weird special case (you could not use x is proc) and was removed from
the language.
Top level routines cannot have the calling convention closure
anymore.
The redis module has been moved out of the standard library. It can
now be installed via Nimble and is located here:
https://github.com/nim-lang/redis
math.RunningStat and its associated procs have been moved from
the math module to a new stats module.

Syntax changes

The parser now considers leading whitespace in front of operators
to determine if an operator is used in prefix or infix position.
This means that finally echo $foo is parsed as people expect,
which is as echo($foo). It used to be parsed as (echo) $ (foo).

echo $ foo continues to be parsed as (echo) $ (foo).

This also means that -1 is always parsed as prefix operator so
code like 0..kArraySize div 2 -1 needs to be changed to
0..kArraySize div 2 - 1.

This release also adds multi-line comments to Nim. The syntax for them is:
#[ comment here ]#. For more details read the section of
the manual.

Iterator changes

Implicit return type inference for iterators has been removed from the language. The following used to work:

nim

iterator it =
  yield 7

This was a strange special case and has been removed. Now you need to write it like so which is consistent with procs:

nim

iterator it: auto =
  yield 7

Closure changes

The semantics of closures changed: Capturing variables that are in loops do not produce a new environment. Nim closures behave like JavaScript closures now.

The following used to work as the environment creation used to be attached to the loop body:

nim

proc outer =
  var s: seq[proc(): int {.closure.}] = @[]
  for i in 0 ..< 30:
    let ii = i
    s.add(proc(): int = return ii*ii)

This behaviour has changed in 0.13.0 and now needs to be written as:

nim

proc outer =
  var s: seq[proc(): int {.closure.}] = @[]
  for i in 0 ..< 30:
    (proc () =
      let ii = i
      s.add(proc(): int = return ii*ii))()

The reason is that environment creations are now only performed once
per proc call. This change is subtle and unfortunate, but:

Affects almost no code out there.
Is easier to implement and we are at a point in Nim's development process where simple+stable wins over perfect-in-theory+unstable-in-practice.
Implies programmers are more in control of where memory is allocated which is beneficial for a systems programming language.

Bugfixes

The list below has been generated based on the commits in Nim's git
repository. As such it lists only the issues which have been closed
via a commit, for a full list see
this link on Github.

Fixed "Generic arguments cannot be used in templates (raising undeclared identifier)"
(#3498)
Fixed "multimethods: Error: internal error: cgmeth.genConv"
(#3550)
Fixed "nimscript - SIGSEGV in except block"
(#3546)
Fixed "Bool literals in macros do not work."
(#3541)
Fixed "Docs: nativesocket.html - 404"
(#3582)
Fixed ""not nil" return types never trigger an error or warning"
(#2285)
Fixed "No warning or error is raised even if not nil is specified "
(#3222)
Fixed "Incorrect fsmonitor add() filter logic"
(#3611)
Fixed ""nimble install nimsuggest" failed"
(#3622)
Fixed "compile time excl cause SIGSEGV"
(#3639)
Fixed "Unable to echo unsigned ints at compile-time"
(#2514)
Fixed "Nested closure iterator produces internal error"
(#1725)
Fixed "C Error on walkDirRec closure"
(#3636)
Fixed "Error in generated c code"
(#3201)
Fixed "C Compile-time error with generic proc type."
(#2659)
Fixed "ICE dereferencing array pointer"
(#2240)
Fixed "Lambda lifting crash"
(#2007)
Fixed "Can't reference outer variables from a closure in an iterator"
(#2604)
Fixed "M&S collector breaks with nested for loops."
(#603)
Fixed "Regression: bad C codegen"
(#3723)
Fixed "JS backend - handle bool type in case statement"
(#3722)
Fixed "linenoise compilation with cpp"
(#3720)
Fixed "(???,???) duplicate case label"
(#3665)
Fixed "linenoise compilation with cpp"
(#3720)
Fixed "Update list of backward incompatibilities for Nim 0.12.0 in the main site"
(#3689)
Fixed "Can't compile nimble with latest devel - codegen bug"
(#3730)

File: jekyll/_posts/2016-01-27-nim-in-action-now-available.md

title: "Nim in Action is now available!" excerpt: "We are proud to announce that Nim in Action, a book about the Nim programming language, is now available!" author: Dominik Picheta

We are proud to announce that Nim in Action, a book about the Nim programming
language, is now available!

The book is available at this URL:
https://www.manning.com/books/nim-in-action

The first three chapters are available for download
as an eBook through Manning's Early Access program. You can download a free
sample of the book containing the first chapter as well!

Nim in Action is currently being written and is expected to be completed by
Summer 2016. If you purchase the eBook you will start receiving new chapters
as they become available. You can also purchase the printed book together with
the eBook for a slightly higher price.

If you do read the book, even if it's just the first chapter, then please share
any comments, suggestions and questions on the
Nim forum or in
Manning's own Author Online forum!

File: jekyll/_posts/2016-06-04-meet-our-bountysource-sponsors.md

title: "Meet our BountySource sponsors"
excerpt: "It has now been two months since we began our fundraiser. Time to meet
our current sponsors."

author: Dominik Picheta

It has now been two months since we began our
BountySource fundraiser. We
promised to create a "Current sponsors" page and are happy to announce that
it is now live here.

We are happy to say that last month we raised more than in the previous month!
A staggering $862 was raised during that month and we thank each and every one
of you once again for your generous contributions.

We are gearing up for a brand new release of Nim that includes many bug fixes
and some new features. In the meantime, as always, feel free to get in
touch with us via Twitter, the
#nim channel on Freenode
or via email at [email protected].

Thanks for reading!

1. Project Overview & Quickstart (nim-lang/highlite.html) Copy Chapter

highlite.html

Repository Details Copy Section

2. Official Technical Reference & Guides (nim-lang/website) Copy Chapter

File: README.md Copy Chapter

Nim website development

Developing Copy Chapter

License Copy Chapter

File: LICENSE.md Copy Chapter

You are free to Copy Chapter

Under the following terms Copy Chapter

Notices Copy Chapter

For more details Copy Chapter

File: jekyll/_config.yml Copy Chapter

Site settings

defaults: Copy Chapter

Build settings

File: jekyll/community.md Copy Chapter

layout: page title: Community css_class: community Copy Chapter

Community

No matter the communication medium, we hope that you will find a place in our community. Just remember to [be kind](https://boz.com/articles/be-kind).

Chat rooms

Forum

Twitter

Blog

Reddit

StackOverflow

Meetups

Issues and RFCs

Wiki

Users and contributors map

File: jekyll/donate.md Copy Chapter

layout: default title: Donate css_class: donate Copy Chapter

Donate

Fund Nim to support its development or find out about the commercial support that we offer.

Open Collective

Commercial support

Priority bug fixes Copy Chapter

Feature requests Copy Chapter

Other ways to donate

File: jekyll/faq.md Copy Chapter

layout: page title: FAQ css_class: faq Copy Chapter

Frequently Asked Questions

General questions

Why yet another programming language? Copy Chapter

How stable is Nim? Copy Chapter

How about security and memory safety? Copy Chapter

How is Nim licensed? Copy Chapter

What about JVM/CLR backends? Copy Chapter

What about editor support? Copy Chapter

What have been the major influences in the language's design? Copy Chapter

Why is it named ``proc``? Copy Chapter

Compilation FAQ

Which option to use for the fastest executable? Copy Chapter

Which option to use for the smallest executable? Copy Chapter

How do I use a different C compiler than the default one? Copy Chapter

File: jekyll/install.md Copy Chapter

layout: default title: Download css_class: install Copy Chapter

Install Nim

text CopyWant a nightly build? </h1> We offer nightly builds both for the cutting-edge devel branch and for backports to our stable branch. <a class="pure-button" href="https://github.com/nim-lang/nightlies/releases">Get nightlies</a>

Install previous versions

File: jekyll/install_unix.md Copy Chapter

layout: page title: Unix installation css_class: install_unix current: Install Copy Chapter

Install Nim on Unix

Installation using ``choosenim``

Manual installation

Pre-built binaries for Linux Copy Chapter

Pre-built binaries for macOS Copy Chapter

Source archive Copy Chapter

Configuring the ``PATH`` environment variable for a manual installation Copy Chapter

Notes about compiler dependencies

macOS Copy Chapter

Linux Copy Chapter

Other dependencies Copy Chapter

Installation using package managers

Arch Linux Copy Chapter

Debian / Ubuntu Copy Chapter

Docker Copy Chapter

Fedora Copy Chapter

FreeBSD Copy Chapter

1. Project Overview & Quickstart (nim-lang/highlite.html)

Repository Details

2. Official Technical Reference & Guides (nim-lang/website)

File: README.md

Developing

License

File: LICENSE.md

You are free to

Under the following terms

Notices

For more details

File: jekyll/_config.yml

defaults:

File: jekyll/community.md

layout: page title: Community css_class: community

File: jekyll/donate.md

layout: default title: Donate css_class: donate

Priority bug fixes

Feature requests

File: jekyll/faq.md

layout: page title: FAQ css_class: faq

Why yet another programming language?

How stable is Nim?

How about security and memory safety?

How is Nim licensed?

What about JVM/CLR backends?

What about editor support?

What have been the major influences in the language's design?

Why is it named ``proc``?

Which option to use for the fastest executable?

Which option to use for the smallest executable?

How do I use a different C compiler than the default one?

File: jekyll/install.md

layout: default title: Download css_class: install

text
`Want a nightly build? </h1> We offer nightly builds both for the cutting-edge devel branch and for backports to our stable branch. <a class="pure-button" href="https://github.com/nim-lang/nightlies/releases">Get nightlies</a>`

File: jekyll/install_unix.md

layout: page title: Unix installation css_class: install_unix current: Install

Pre-built binaries for Linux

Pre-built binaries for macOS

Source archive

Configuring the ``PATH`` environment variable for a manual installation

macOS

Linux

Other dependencies

Arch Linux

Debian / Ubuntu

Docker

Fedora

FreeBSD

macOS

OpenBSD

openSUSE

Void Linux

File: jekyll/install_windows.md

layout: page title: Windows installation css_class: install_windows current: Install

Configuring the ``PATH`` environment variable

Compiler dependencies

File: jekyll/releases.json

layout: null

File: jekyll/_data/nim_releases.json

File: jekyll/_data/sponsors_meta.json

File: jekyll/_posts/2009-12-21-version-086-released.md

title: "Version 0.8.6 released" author: Andreas Rumpf

Bugfixes

Additions

Changes affecting backwards compatibility

File: jekyll/_posts/2010-03-14-version-088-released.md

title: "Version 0.8.8 released" author: Andreas Rumpf

Bugfixes

Additions

Changes affecting backwards compatibility

File: jekyll/_posts/2010-10-20-version-0810-released.md

title: "Version 0.8.10 released" author: Andreas Rumpf

Bugfixes

Changes affecting backwards compatibility

Additions

File: jekyll/_posts/2011-07-10-version-0812-released.md

title: "Version 0.8.12 released" author: Andreas Rumpf

Bugfixes

Changes affecting backwards compatibility