101 courses · 1250 animated lessons · beginner courses free with an account
Six short lessons each: watch the animation, read the idea in plain words, answer a few questions. Grouped by where you will meet each language or platform — not sure where to start? See the specializations map.
Assembly is the human-readable form of machine code: no variables, no types, just registers, memory and instructions. Six lessons on x86-64 Linux with NASM syntax, from a hello world that talks to the kernel directly to reading what a C compiler emits.
Start the courseTwenty modules on x86-64 Linux with NASM 2.16 and the System V ABI: data layout and addressing, flags and arithmetic, calling conventions and linking with C, SSE and AVX, atomics, debugging with gdb, performance, compiler output, security and other architectures.
Start the courseC is small, fast and honest: what you write is very close to what the CPU runs. Six lessons cover compiling, fixed-size types, arrays as raw memory, pointers, undefined behaviour and the heap — the model every other systems language is measured against.
Start the courseTwenty modules for someone who has written a first C program and freed their first malloc. Arc 1 goes deep on types and memory layout; arc 2 covers program structure, errors and the standard library; arc 3 is the toolchain — Make and CMake, sanitizers, gdb, profiling and tests; arc 4 brings threads, atomics, libraries, JSON and C23.
Start the courseC++ keeps C's machine model and adds the abstractions big programs need: real strings and vectors, references, classes whose destructors release resources for you, smart pointers and templates. Six lessons from a first stream to generic code.
Start the courseThe second C++ course. Twenty modules on the C++20/23 a working developer needs: move semantics and smart pointers, errors as values, containers, ranges and std::format, concepts, CMake, GoogleTest, sanitizers, std::filesystem, threads and futures, constexpr, JSON, and packaging with vcpkg.
Start the courseCUDA lets a C program hand work to an NVIDIA GPU: you write one function, launch it across thousands of threads, and move data between host and device memory. Six lessons from a first kernel to a timed vector add — for readers who already know some C.
Start the courseTwenty modules for someone who finished the CUDA beginner course, written for CUDA 13 with C++17: error handling, indexing and memory kinds, shared memory and coalescing, reductions and warps, streams and graphs, libraries, Nsight and compute-sanitizer, then precision, multi-GPU, nvcc builds and modern C++.
Start the courseRust gives you C-level speed and control, then makes the compiler prove your program cannot corrupt memory or race between threads. Six lessons: cargo, bindings, vectors, ownership and borrowing, Result and match, and a struct with a trait and a test.
Start the courseTwenty modules for someone who finished the beginner course: enums and patterns, generics, traits in depth, trait objects, lifetimes, error handling with ? and custom error types, closures, iterators, collections, strings, smart pointers, modules, Cargo, testing, threads, async with tokio, files, JSON with serde, unsafe and FFI, and release builds.
Start the courseZig is a small systems language built to replace C: explicit about memory, honest about errors, and able to run ordinary code at compile time. Six lessons cover running a file, integer types, arrays and slices, error unions, comptime, and allocators with defer.
Start the courseTwenty modules for someone who finished the Zig beginner course: structs, tagged unions, optionals and pointers; allocator strategies, error sets and generics; ArrayList, HashMap and iterators; build.zig, packages, testing, cross-compilation and safety modes; then Zig 0.17's std.Io for files, JSON, C interop and concurrency.
Start the coursePython reads almost like English and runs the moment you press enter. Six lessons take you from your first print to dictionaries — every concept animated, every lesson checked.
Start the courseGo compiles to a single binary, keeps the language small enough to hold in your head, and makes concurrency a one-keyword affair. Six lessons from hello world to goroutines.
Start the courseC# runs on the .NET runtime and powers web APIs, desktop apps, Unity games and cloud services. Six lessons from dotnet run to a working HTTP endpoint: the runtime, types, lists, classes and records, LINQ, and a minimal web API with async/await.
Start the courseYou can write a class, query a list with LINQ and stand up a minimal API. This course is what a working C# developer needs next: the toolchain, nullable types, records, generics, patterns, exceptions, iterators, collections, delegates, deeper LINQ, async and concurrency, files, JSON, HttpClient, xUnit, the Generic Host, EF Core, memory and publishing — twenty modules on .NET 10 and C# 14.
HTML says what is on the page; CSS says how it looks. Six lessons build a real page from the first element to a responsive layout — semantics, forms, the box model, selectors and the cascade, flexbox and grid — with no JavaScript required.
Start the courseJavaScript is the only language a web page can run without a plug-in, and it now runs servers, phones and build tools too. Six lessons go from your first console.log to closures, the DOM, events and async code — each one animated, each one checked.
Start the courseYou can write a script, a closure and an async fetch. This course teaches the JavaScript a working developer is expected to know next: modern syntax, coercion rules, prototypes and classes, iteration protocols and generators, the event loop and promise combinators, ES modules, errors, JSON, regular expressions, Intl and testing with the runtime's own tools.
Start the courseTypeScript is JavaScript plus a type checker: the same code you already write, with mistakes caught in the editor instead of in production. Six lessons cover only what it adds — annotations, interfaces, unions and narrowing, generics, and how it all compiles away.
Dart is the language behind Flutter, Google's toolkit for building iOS, Android, web and desktop apps from one codebase. Six lessons from a first print through null safety, classes, async code and your first Flutter widget tree.
Start the courseYou can write a class, await a Future and build a widget. This course is what a working Dart developer needs next: records, patterns and sealed types, generics and extension types, null safety and error idioms, lazy iterables, futures, streams and isolates, files and JSON, pub, the analyzer, tests, debugging, dart compile and one module on Flutter state.
Start the courseObjective-C is a thin layer of objects and message sending on top of plain C. Swift is the modern path for Apple platforms, but decades of iOS and macOS code are written in Objective-C. Six lessons so you can read it, run it and fix it.
Start the courseTwenty modules in four arcs. Language depth: properties, blocks, retain cycles, categories and protocols. Foundation: boxing, the copy contract, sorting, KVC/KVO, NSError, JSON and files. Concurrency and types: GCD queues, groups and barriers, nullability, generics and the runtime. Shipping: clang and xcodebuild, Swift interop, XCTest and memory debugging.
Julia is a language for scientific and numerical computing that is easy to write and compiles to fast native code. Six lessons cover the REPL, arrays and dot-broadcasting, multiple dispatch, types and the JIT, packages and environments, and your first numerical simulation.
Start the courseYou can run a script, broadcast over an array and define a method. Now learn how Julia really works: the type tree, structs and parametric types, dispatch rules, iteration and broadcasting internals, macros, modules and Project.toml, Test, files and JSON, type stability and profiling, threads, DataFrames.jl and calling C and Python — on Julia 1.12.
Start the courseMATLAB is the numerical environment engineers reach for: matrices are the native data type, plots are one command away, and toolboxes cover signals, images, control and more. Six lessons cover matrices, indexing, vectorised operations, plotting, scripts versus functions, and where toolboxes fit in real engineering work.
Start the courseTerraform turns infrastructure into code: you declare what should exist, and it plans and applies the difference. Six lessons take you from your first resource block to modules — every concept animated.
Start the courseAWS and Azure each ship their own way to describe infrastructure as code. Six lessons cover CloudFormation (a template becomes a stack), its template anatomy and change sets, Bicep on Azure, the AWS CDK that generates CloudFormation from TypeScript or Python, and an honest guide to choosing these over Terraform.
Start the courseA Dockerfile is the recipe for a container image: a base, some commands, your files, one command to start. Six lessons start with zero Docker knowledge and cover images versus containers, the core instructions, layers and the cache, the build context and .dockerignore, multi-stage builds, and running with ports and volumes.
Start the courseGroovy is a dynamic language for the JVM, and it is what Jenkins pipelines and Gradle build files are written in. Six lessons take you from your first script to closures, a Jenkinsfile stage by stage and a real build.gradle — every concept animated, every lesson checked.
Bash is the command line on Linux, macOS and most servers — and the glue language of ops, CI and deployment. Six lessons: commands and arguments, variables and quoting, pipes and redirection, loops, exit codes and if, and a real script that fails safely.
Start the courseTwenty modules on what a working engineer needs after the basics: strict mode and quoting done right, parameter expansion, indexed and associative arrays, [[ ]] and regex, functions with real scope, getopts, traps and cleanup, file descriptors and here-docs, safe line reading, awk, sed, jq and printf, background jobs, debugging, bats tests, cron and systemd timers, and portable shipping.
Start the courseLua is small enough to learn in a weekend and small enough to embed in anything, which is why it runs your Neovim config, your Redis scripts and half the games you play. Six lessons: values, tables, closures, metatables, coroutines and where Lua lives.
Start the courseTwenty modules for someone who finished the Lua beginner course. Arc one goes deep on the core: scopes and 5.4 attributes, integers versus floats, varargs, the table library, iterators. Arc two: patterns, strings, errors and object systems. Arc three is the toolchain: garbage collection, modules, LuaRocks, busted, files, JSON. Arc four: generators, sandboxes, the C API, hosts and profiling.
ABAP is the programming language of SAP systems, running finance, logistics and HR at most of the Fortune 500. Six lessons: a first report, data declarations, internal tables, SELECT from database tables, LOOP AT, and an ALV grid — in modern ABAP syntax, plus how to get a system to practise on.
Start the courseTwenty modules of modern ABAP (7.40 syntax to ABAP 7.58 and ABAP Cloud): constructor expressions, strings, internal tables and loops, OO design and exceptions, ABAP SQL and CDS, ABAP Unit, performance, tooling, RAP and background jobs.
Start the courseCOBOL runs core banking, insurance and government batch systems, and it is still maintained and hired for. Six lessons: the four divisions, PICTURE clauses, exact fixed-point money arithmetic, PERFORM loops, records and files, and a real batch program — all runnable with the free GnuCOBOL compiler.
Start the courseTwenty modules on GnuCOBOL 3.2 and the COBOL 2023 standard, with IBM Enterprise COBOL differences noted: copybooks, level numbers, packed decimals, edited pictures, EVALUATE, strings, tables, subprograms, files, SORT, dates, SQL and JCL.
Clojure is a modern Lisp that runs on the Java virtual machine: code is data, data is immutable, and the REPL is where you work. Six lessons from your first form to a project you can run with deps.edn.
Start the courseTwenty modules for someone who has finished the beginner course. Arc one goes deep on sequences, persistent collections, destructuring and transducers; arc two covers polymorphism and macros; arc three is state, concurrency, Java interop and files; arc four is spec, clojure.test, vars, the REPL workflow and building an uberjar with tools.build. Every module has real code on Clojure 1.12.
Start the courseErlang was built at Ericsson to run telephone switches that never stop. Immutable data, pattern matching and cheap isolated processes make it the language behind WhatsApp-scale messaging and RabbitMQ. Six lessons from a module to spawn, receive and OTP supervision.
Start the courseThe second Erlang course. Four arcs: data in depth (guards, records, maps, binaries, comprehensions); functions, errors and process linking up to gen_server and supervisor design; the application, ETS, rebar3, typespecs and file/JSON toolchain; and quality and operations with EUnit, Common Test, releases, distribution and tracing.
Amazon Web Services runs a huge share of the internet, and every action in it can be clicked in the web console or typed in the AWS CLI. Six lessons show both doors each time: your account and Regions, IAM users and policies, S3 buckets, an EC2 server you can SSH into, IAM roles that give that server access without keys, and cleaning up so the bill stays at zero.
Start the courseCloudflare is an edge platform: DNS and a proxy in front of your domain, Workers that run your code in every data centre, and R2 object storage without egress fees. Six lessons show every step through both the dashboard and the wrangler CLI: a zone and its DNS records, scoped API tokens, your first Worker, an R2 bucket, the binding that lets the Worker read it with no credentials, and cleaning up.
Start the courseGoogle Cloud runs on projects, and every action in one can be clicked in the web console or typed with the gcloud CLI. Six lessons show both doors each time: a project and its billing account, IAM principals and roles, Cloud Storage buckets, a Compute Engine VM you can SSH into, a service account that lets that VM read a bucket with no key file, and cleaning up so the bill stays at zero.
Start the courseTwenty modules that take you from scripts to maintainable MATLAB: numeric types, strings, cells, structs and tables; logical indexing, broadcasting and control flow; function design, handles and classes; files, JSON, datetimes and figures; numerics, performance, testing, projects and parallel computing.
Every action in Microsoft Azure can be clicked in the Azure portal or typed in the az CLI. Six lessons show both doors each time: subscription, resource groups and regions; Entra ID and RBAC roles; a storage account with blobs; a Linux VM you SSH into; a managed identity that lets that VM read storage without keys; and deleting the resource group so the bill stops.