• View
• Edit
• History
• Print

Nim 2

#############################

I used Nim in 2018. Here are my old notes. I even solved Advent of Code 2018 in Nim (GitHub link). Unfortunately, I stoppped using Nim after that. Now, in 2026, I decided to use it again. Since I forgot most of it, I'll have to re-learn the language. I will collect my new (and hopefully improved) notes here.

These notes are for people who already know a programming language. This is not an introduction to programming with Nim. I compare Nim to mainly Python and sometimes to C in these notes.

I set up an issue tracker for these notes ⚠️

𝥶,↔, →, ←, ⤷, ⇨, ⇒, —, •, ▸, ›, ✦, ✓, ✔, ✅, ☑,

---

Links

• My Nim Index
• ⇨ Nim Exercises
• HQ (font in logo)
• Docs | Forum | /r/nim | FAQ | Style Guide
• Nim basics tutorial (an excellent tutorial; I started with this in 2018)
• links / blog posts / videos
• Nim Playground (compile and run Nim snippets in your browser)
• Nim at Rosetta Code (1-C, C-E, E-H, H-M, M-P, P-R, R-S, S-W, W-Z)
• Nim Programming Language @ YouTube
  • NimConf 2020 | NimConf 2021 | NimConf 2022 | NimConf 2024
• Packages
  • stdlib
  • package directories
    • Nim Package Directory
    • nimpkgs
    • Nim Packages
  • Awesome Nim (curated packages)
• My Nim projects on GitHub
  • all of them
• The history of Nim
  • Nim @ Wikipedia
  • Andreas Rumpf, the creator of the language
  • Nimrod → Nim
  • Nimony, the future of Nim

---

Notes

• Which Nim version? ✓
• Features of Nim
• installation (Linux, Windows) and compiling a "Hello, World" program ✓
  • installation under FreeBSD and MacOS ✓
  • update to latest version ✓
  • ⇨ docker image
• important folders ✓
• install a REPL (inim) ✓
• nimble tips (install, uninstall, etc.)
• compilation (debug mode, release mode, fast EXE, small EXE)
  • compile to JavaScript
  • compiling a C program with zig (+ cross-compiling a C program with Zig)
  • compiling a Nim program with zig (+ cross-compiling a Nim program with Zig)
• run a program without explicitly compiling it
• running Nim programs as scripts with shebang (#!/usr/bin/env nimbang)
• text editors
  • VS Code settings
    • my current VS Code setup
    • VS Code tips
  • Zed Editor settings
• code snippets
• template to start with
• code beautifier (code formatter; Python: Ruff; here: nph)
• shell settings (fish, bash, zsh)
• using AI for learning Nim
• disable Avast Antivirus for a folder
• create a project
  • add dependency

---

Nim Basics

• indentation ✓
• comments ✓
• basic types + type info, type suffixes ✓
• variables
  • declaring variables (var, let, const) ✓
  • const example
  • default values of variables (no garbage value)
  • swap two variables
• print to stdout
  • echo + stdout.write() + What is echo() actually?
  • formatted output (.format())
  • pretty print a number (2026 → 2,026)
  • print in a loop + sleep + flush
• increment a variable (n += 1) + pass by reference ✓
• type conversions / conversions
  • int ↔ float; anything → string + `$` (toString())
  • string → int; string → float (parseInt(), parseFloat())
  • binary ↔ decimal, hexa ↔ decimal (fromBin, toBin, fromHex, toHex)
• math
  • PI
  • arithmetic operations (+, -, *, /, modulo, integer division)
  • rounding
  • raise to power (x^2)
  • sum, product, factorial (sum, prod, fac)
• characters
  • testing an ASCII char (isDigit? isLowercase?)
  • converting a char (toLowercase, toUppercase)
  • char digit to int ('5' → 5)
  • ord() for ASCII and Unicode (character → code point)
  • chr() (code point → character)
• strings
  • concatenation
  • string formatting (string interpolation: &"…", .format())
  • normal, raw, multiline
  • Mutable or immutable? + stringbuffer
  • how an immutable string differs from Python
  • for loop on an ASCII string (access characters)
  • slicing an ASCII text
  • reverse a string (Python: s[::-1]) + length of Unicode strings
  • converting a text (toLowercase, toUppercase)
  • repeat a string
  • common string methods (find, toLowerAscii, toUpperAscii, toLower, toUpper, startsWith, endsWith, replace, split, join)
  • strip() + lstrip(), rstrip()
  • removePrefix, removeSuffix + dup macro from std/sugar
  • Levenshtein distance (aka edit distance)
  • from parse import parse (std/strscans, scanf())
• Unicode strings
  • under Unicode string I mean here a string that contains non-ASCII character(s)
  • remove accents and keep ASCII characters only
  • iterate over the characters of a Unicode string
  • check if a text is ASCII only + little generic function
• slicing
  • safe slicing (like in Python) + auto type
• style insensitive identifier (variable/procedure) names ✓
• stropping (use a keyword as a variable name)
• logical operators
• control structures
  • if-elif-else + if expression + ternary operator
  • case statement (case of, aka switch)
  • while loop
  • break and continue + block keyword
  • for loop + countup(), countdown() ✓
• procedures and functions
  • preferred order (func → proc → template → macro)
  • proc, func ✓
  • debugEcho ✓
  • ignore the return value (discard) ✓
  • forward declaration
  • how to return a value from a function (variations) ✓
  • grouping the input parameters ✓
  • UFCS (Uniform Function Call Syntax) ✓
  • procedure overloading (aka method overloading)
  • optional parameters
• parameter passing
  • terminology + pass by value, shadowing, pass by reference ✓
• read from the standard input
  • simple solution (Python: input())
  • intermediate solution (arrows work, like in bash) + throw exception
  • advanced solution (previous ^^^ + Unicode support)
• tests
  • assert
  • unit tests (std/unittest)
  • assert vs check
  • runnableExamples (Python: doctest)
• sizeof
• range object (1..100)
• types
  • user-defined types: objects, tuples, enums
  • type definition (give a more readable name to an existing type; C: typedef)
  • subrange types (Natural, Positive, Negative, etc.) + range object vs range type
  • enums
  • ⇨ tuples (see also)
  • ⇨ objects (see also)
• write and use your own module
  • simple example ✓
• static arrays
  • basic usage
  • passing static arrays to procedures + openArray
• sequences (dynamic array) [Python: list]
  • basic usage + set capacity + set length
  • filter() and map() (Python: list comprehensions) + =>, filterIt, mapIt, collect:
  • all() and any()
  • reverse(), reversed()
  • matrix (list of lists)
  • remove duplicates and keep order
• sets
  • There are 4 different sets in Nim
  • (1) built-in set type (for storing ordinal values; often used for characters and flags)
  • (2) HashSet (for storing anything; like Python's set data structure)
  • (3) OrderedSet
  • remove duplicates + keep order
  • (4) IntSet
  • Which one to use?
• tuples
  • anonymous tuples (simplest tuples)
  • defining type for anonymous tuples
  • named tuple on the fly
  • named tuple with custom type + writing a class + creating an object + using a constructor proc
  • comparing tuples
• objects (C: structs/records; Python: classes)
  • simple examples
  • value types / value semantics
  • reference types / reference semantics
  • object comparison (==) + dereference operator (p[])
• operators
  • in operator + notin
  • == (comparison)
• iterators
  • items(), pairs()
  • mitems(), mpairs()
• exception handling
  • basic usage
• file handling, file operations
  • process file line by line (read, write, append)
  • read the whole content (readFile, splitlines; Python: f.read(), f.readlines())
  • write string to file (writeFile)
  • from pathlib import Path
• OS interface
  • terminate and exit (exit(), quit())
  • command-line arguments
    • the Nim way
    • the Python way (sys.argv)
    • the simplest way
  • platform info ("linux", "amd64")
  • which (the Unix which command)
  • make file executable (chmod u+x)
  • filters (cat file.txt | upper)
  • HOME directory
  • environment variables
  • Python's os, os.path and glob modules and their Nim equivalents + file size
  • execute a shell command (call an external process; Python: os.system())
• random numbers
  • randint()
• dates and times
  • get current date (ex.: 2026_04_26) + date object → string + string → date object
  • create a date object from year, month, day + get info of that date
  • yesterday, tomorrow 🏎️
  • time difference between two dates
  • epoch time (aka Unix time) + measure execution time/elapsed time/runtime + hyperfine
• hashes
  • generate a random hash
  • MD5 hash + md5 hash of an ISO file + speed comparisons
• json
  • read a list of numbers (+ JSON string → native type)
  • read a dictionary
  • create a JSON file (write in JSON format)
• colors and terminal
  • colors in the terminal #1 (manually) + C and Python codes at the bottom
  • colors in the terminal #2 (std/terminal)
  • terminal magic (hide cursor, erase line, move cursor, etc.)
• sorting
  • basic sorting
  • advanced sorting + cmp() + anonymous (lambda) functions
• regexp (std/re)
  • simple examples
  • ⇨ extract links from a webpage #2 (with regular expressions)
• exit
  • addExitProc() (execute a proc before quitting; C: atexit())

Intermediate / Advanced Topics

• preferred order (func → proc → template → macro)
• generics
  • simple examples
• iterators
  • basic usage (inline iterators) + iterator to seq
  • finite and infinite iterators
  • Python's generator-like iterator
• templates
  • basic usage + withTimer
• Nim ↔ Python interaction
  • from Nim, call Python (Nim → Python)
  • from Nim, call Python's eval() function
• Big Integers
  • bigints library
  • bigints library is slow
  • mapm, a faster bigints alternative
• pragmas
  • What is a pragma?
  • ⇨ pure enums
  • raises
  • global (static variable)
• web-related stuff
  • download a webpage (get it as a string) + SSL error + config.nims + retry
  • extract links from a webpage #1
  • extract links from a webpage #2 (with regular expressions)
  • open a URL in the default web browser