
Set up the Nim environment on Windows and Linux by installing Nim, updating path variables, and using VS Code for editing; verify with nim -h and follow Linux installer steps.
Learn Nim in five minutes by exploring variables with let, mutable and immutable examples, comments, tuples, sequences, types, and compile-time when and for loops.
Learn how to name values in Nim, declare mutable variables with var, use type inference, and enforce immutable const and let assignments, while aligning code with spaces for indentation.
Explore Nim's basic data types, including integers, floating point numbers, characters, strings, and booleans, and learn their operations, conversions, and common comparisons and logical expressions.
Explore control flow in Nim using boolean conditions with if statements, elif branches, and else, then learn case statements and lists for alternative paths.
Explore how containers in Nim act as data types that store collections and enable iteration, indexing, and slicing, including arrays, sequences, tuples, and zero-based indexing.
Explore Nim procedures and functions, including definitions, parameter and return type signatures, the result variable, and testing, with examples like finding max of two values.
Explore Nim modules and the standard library, import modules with the import syntax, use the nimble package manager, and organize code in subdirectories, including exporting plus and hiding minus.
Explore Nim playground in your web browser, use the text editor to write code, run it online, and select compilation targets like C or C++, then view results.
Learn to interact with user input in Nim by reading from files and the console, parsing numbers and strings, and computing sums and averages.
Explore Nim exceptions: heap-allocated objects with an error-suffixed type hierarchy, raised in exceptional cases, and handled with try/except to manage value, overflow, and io errors while inspecting current exception messages.
Explore generics in Nim, parameterizing procs, iterators, and types with type parameters in square brackets. Build and traverse a generic binary tree with left and right children.
Learn templates in Nim, a substitution mechanism for names and abstract syntax trees that integrates with the compiler. Explore operator templates and lazy evaluation with examples as a log procedure.
The final video wraps up the Nim programming language course and invites you to explore tutorial part two, object oriented programming, macros, the standard library, language manual, and tools documentation.
Welcome,
Nim is a statically typed compiled systems programming language. It combines successful concepts from mature languages like Python, Ada and Modula.
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.
You will find the source files for the corresponding videos in this git repository.
Happy Coding!