• 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
• 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?
• installation and compiling a "Hello, World" program
  • update to latest version
  • ⇨ docker image
• important folders
• install a REPL + how to (un)install a package with nimble
• nimble tips
• 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)
• VS Code settings
  • my current VS Code setup
  • VS Code tips
• 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
  • print in a loop + sleep + flush
• increment a variable (n += 1) + pass by reference
• type conversions
  • int ↔ float; anything → string + `$` (toString())
  • string → int; string → float (parseInt(), parseFloat())
• 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()
• case 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
  • ignore the return value
  • forward declaration
  • how to return a value from a function (variations)
  • grouping the input parameters
  • UFCS (Uniform Function Call Syntax)
  • procedure overloading
  • optional parameters
• parameter passing
  • terminology + pass by value, shadowing, pass by reference
• read from the standard input
  • simple solution (Python: input())
  • advanced solution (arrows work, like in bash) + throw exception
• 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)
• sets
  • built-in set type (for storing ordinal values)
  • HashSet? (for storing anything)
• 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
• 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()
• file handling
  • process file line by line (read, write, append)
  • read the whole content (readFile, splitlines; Python: f.read(), f.readlines())
  • write string to file (writeFile)
• exception handling
  • basic usage
• OS interface
  • terminate and exit (exit(), quit())
  • command-line arguments
    • The Nim way
    • The Python way (sys.argv)
  • platform info ("linux", "amd64")
  • which (the Unix which command)
  • make file executable (chmod u+x)
  • filter command (cat file.txt | upper)
• 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
• json
  • read a list of numbers (+ JSON string → native type)
  • read a dictionary
  • create a JSON file (write in JSON format)
• colors
  • ANSI colors in the terminal (manually) + C code at the bottom
• sorting
  • basic sorting
  • advanced sorting + cmp() + anonymous (lambda) functions
• regexp (std/re)
  • simple examples
  • ⇨ extract links from a webpage #2 (with regular expressions)

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
• working with BigInts
  • bigints library
  • bigints library is slow
• 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
  • extract links from a webpage #1
  • extract links from a webpage #2 (with regular expressions)