nim-lang.org Open in urlscan Pro
2606:4700:3031::6815:52a  Public Scan

Form analysis
0 forms found in the DOM

Text Content

 * Blog
 * Features
 * Download
 * Documentation
 * Forum
 * Donate
 * Source




EFFICIENT, EXPRESSIVE, ELEGANT


NIM IS A STATICALLY TYPED COMPILED SYSTEMS PROGRAMMING LANGUAGE. IT COMBINES
SUCCESSFUL CONCEPTS FROM MATURE LANGUAGES LIKE PYTHON, ADA AND MODULA.

Install Nim 1.6.6 Try it online


EFFICIENT

 * Nim generates native dependency-free executables, not dependent on a virtual
   machine, which are small and allow easy redistribution.
 * The Nim compiler and the generated executables support all major platforms
   like Windows, Linux, BSD and macOS.
 * Nim's memory management is deterministic and customizable with destructors
   and move semantics, inspired by C++ and Rust. It is well-suited for embedded,
   hard-realtime systems.
 * Modern concepts like zero-overhead iterators and compile-time evaluation of
   user-defined functions, in combination with the preference of value-based
   datatypes allocated on the stack, lead to extremely performant code.
 * Support for various backends: it compiles to C, C++ or JavaScript so that Nim
   can be used for all backend and frontend needs.


EXPRESSIVE

 * Nim is self-contained: the compiler and the standard library are implemented
   in Nim.
 * Nim has a powerful macro system which allows direct manipulation of the AST,
   offering nearly unlimited opportunities.


ELEGANT

 * Macros cannot change Nim's syntax because there is no need for it — the
   syntax is flexible enough.
 * Modern type system with local type inference, tuples, generics and sum types.
 * Statements are grouped by indentation but can span multiple lines.

Simple example If…else, Case switch Basic math String operations Comprehensions

import std/strformat

type
  Person = object
    name: string
    age: Natural # Ensures the age is positive

let people = [
  Person(name: "John", age: 45),
  Person(name: "Kate", age: 30)
]

for person in people:
  # Type-safe string interpolation,
  # evaluated at compile time.
  echo(fmt"{person.name} is {person.age} years old")


# Thanks to Nim's 'iterator' and 'yield' constructs,
# iterators are as easy to write as ordinary
# functions. They are compiled to inline loops.
iterator oddNumbers[Idx, T](a: array[Idx, T]): T =
  for x in a:
    if x mod 2 == 1:
      yield x

for odd in oddNumbers([3, 6, 9, 12, 15, 18]):
  echo odd


# Use Nim's macro system to transform a dense
# data-centric description of x86 instructions
# into lookup tables that are used by
# assemblers and JITs.
import macros, strutils

macro toLookupTable(data: static[string]): untyped =
  result = newTree(nnkBracket)
  for w in data.split(';'):
    result.add newLit(w)

const
  data = "mov;btc;cli;xor"
  opcodes = toLookupTable(data)

for o in opcodes:
  echo o

var conditional = 42

if conditional < 0:
  echo "conditional < 0"
elif conditional > 0:
  echo "conditional > 0"
else:
  echo "conditional == 0"

var ternary = if conditional == 42: true else: false

var another =
  if conditional == 0:
    "zero"
  elif conditional mod 2 == 0:
    "even"
  else:
    "odd"


# Case switch.
var letter = 'c'

case letter
of 'a':
  echo "letter is 'a'"
of 'b', 'c':
  echo "letter is 'b' or 'c'"
of 'd'..'h':
  echo "letter is between 'd' and 'h'"
else:
  echo "letter is another character"

import std/math

# Basic math.
assert 1 + 2 == 3        # Sum
assert 4 - 1 == 3        # Subtraction
assert 2 * 2 == 4        # Multiplication
assert 4 / 2 == 2.0      # Division
assert 4 div 2 == 2      # Integer Division
assert 2 ^ 3 == 8        # Power
assert 4 mod 2 == 0      # Modulo
assert (2 xor 4) == 6    # XOR
assert (4 shr 2) == 1    # Shift Right
assert PI * 2 == TAU     # PI and TAU
assert sqrt(4.0) == 2.0  # Square Root
assert round(3.5) == 4.0 # Round
assert isPowerOfTwo(16)  # Powers of Two
assert floor(2.9) == 2.0 # Floor
assert ceil(2.9) == 3.0  # Ceil
assert cos(TAU) == 1.0   # Cosine
assert gcd(12, 8) == 4   # Greatest common divisor
assert trunc(1.75) == 1.0     # Truncate
assert floorMod(8, 3) == 2    # Floor Modulo
assert floorDiv(8, 3) == 2    # Floor Division
assert hypot(4.0, 3.0) == 5.0 # Hypotenuse
assert gamma(4.0) == 6.0      # Gamma function
assert radToDeg(TAU) == 360.0 # Radians to Degrees
assert clamp(1.4, 0.0 .. 1.0) == 1.0 # Clamp
assert almostEqual(PI, 3.14159265358979)
assert euclDiv(-13, -3) == 5  # Euclidean Division
assert euclMod(-13, 3) == 2   # Euclidean Modulo

import std/[strutils, strscans]

assert "con" & "cat" == "concat"
assert "    a    ".strip == "a"
assert "42".parseInt == 42
assert "3.14".parseFloat == 3.14
assert "0x666".parseHexInt == 1638
assert "TrUe".parseBool == true
assert "0o777".parseOctInt == 511
assert "a".repeat(9) == "aaaaaaaaa"
assert "abc".startsWith("ab")
assert "abc".endsWith("bc")
assert ["a", "b", "c"].join == "abc"
assert "abcd".find("c") == 2
assert "a x a y a z".count("a") == 3
assert "A__B__C".normalize == "abc"
assert "a,b".split(",") == @["a", "b"]
assert "a".center(5) == "  a  "
assert "a".indent(4) == "    a"
assert "    a".unindent(4) == "a"

for word in tokenize("This is an example"):
  echo word

let (ok, year, month, day) = scanTuple("1000-01-01", "$i-$i-$i")
if ok:
  assert year == 1000
  assert month == 1
  assert day == 1

import std/[sugar, tables, sets, sequtils, strutils]

let variable0 = collect(newSeq):
  for item in @[-9, 1, 42, 0, -1, 9]:
    item * 2

assert variable0 == @[-18, 2, 84, 0, -2, 18]

let variable1 = collect(initTable):
  for key, value in @[0, 5, 9]:
    {key: value div 2}

assert variable1 == {0: 0, 1: 2, 2: 4}.toTable

let variable2 = collect(initHashSet):
  for item in @[-9, 1, 42, 0, -1, 9]:
    {item + item}

assert variable2 == [2, 18, 84, 0, -18, -2].toHashSet

assert toSeq(1..15).mapIt(
    if it mod 15 == 0:  "FizzBuzz"
    elif it mod 5 == 0: "Buzz"
    elif it mod 3 == 0: "Fizz"
    else: $it
  ).join(" ").strip == "1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz"

More examples at RosettaCode…


RECENT ARTICLES

03 September 2022


THIS MONTH WITH NIM: JUNE AND JULY 2022

Home Automation, NimYAML 1.0, and a LaTeX like
29 June 2022


MASTERING NIM - NOW AVAILABLE ON AMAZON

My book 'Mastering Nim - A complete guide to the programming language' is now
available on Amazon
All articles


NIM IN ACTION


THE FIRST NIM BOOK, NIM IN ACTION, IS NOW AVAILABLE FOR PURCHASE AS AN EBOOK OR
PRINTED SOFT COVER BOOK. LEARN THE BASICS SUCH AS NIM'S SYNTAX AND ADVANCED
FEATURES INCLUDING MACROS, AND GAIN PRACTICAL EXPERIENCE WITH THE LANGUAGE BY
BEING LED THROUGH MULTIPLE APPLICATION DEVELOPMENT EXAMPLES.

 * Teaches the basics including the syntax of Nim.
 * Explains how to use the Nimble package manager.
 * Includes step-by-step instructions and explanations of how to develop various
   applications, including a chat program, a Twitter clone and more.

Learn more


SUPPORT NIM


JOIN THE 100+ COMPANIES AND INDIVIDUALS THAT SUPPORT NIM


THE NIM PROJECT IS DEVELOPED GLOBALLY BY A GROUP OF VOLUNTEERS. WE WELCOME
RECURRING DONATIONS, WHICH ENABLE US TO SPEND MORE TIME WORKING ON NIM.

Donate


COMMUNITY


REAL-TIME CHAT

#Libera.chat#nim

Discord/Nim

Gitter/Nim

m#nim:envs.net

#IRC Logs

Telegram/nim_lang


FORUM

forum.nim-lang.org

r/nim

StackOverflow


BUG REPORTS

nim-lang/Nim


TWITTER

@nim_lang

Join the community


LOOKING FOR THE GITHUB REPOSITORY?


THE NIM COMPILER AND TOOLS ARE ALL WRITTEN IN NIM AND LICENSED UNDER THE MIT
LICENSE, WITH MOST DEVELOPMENT TAKING PLACE ON GITHUB. BE SURE TO WATCH THE
REPOSITORY TO GET UPDATES ON NIM'S DEVELOPMENT, OR STAR IT TO GIVE US SOME
BROWNIE POINTS.

Source code

Unless otherwise stated, the content of this page is licensed under the Creative
Commons Attribution 3.0 license. Code displayed on this website is MIT licensed.

This website is available on GitHub and contributions are welcome. Original
website design by Dominik Picheta and Hugo Locurcio. Logo by Joseph Wecker.