Most Dart resources exist for one reason: Flutter.
They teach enough Dart to write a widget, then hand you off to the Flutter docs. Which means most Dart developers know how to build a screen but not how the language actually works. What is a microtask? How do isolates communicate? Why does async/await desugar into a state machine?
I found a curriculum that answers those. It's on KandZ Tuts, and it treats Dart as a language in its own right—not just Flutter's substrate.
Here's the breakdown.
Runtime and Setup (1–2)
The Dart runtime engine, JIT vs AOT compilers, execution architecture, project setup with dart create, and pubspec.yaml.
Language Fundamentals (3–13)
Variables and type inference (var, final, const), built-in types, strings and interpolation, operators, null safety, null-aware operators, control flow, switch and pattern matching, loops, functions and parameters, and first-class functions.
Collections (14–17)
Lists and spread operators, collection if and for, sets, and maps.
Object-Oriented Dart (18–30)
Constructors, const constructors, factory constructors, member visibility, getters and setters, inheritance, abstract classes, implicit interfaces, mixins, class modifiers (base, interface, final, sealed), enums, extension methods, and extension types.
Advanced Types (31–35)
Generics and type constraints, records and destructuring, pattern matching in assignments, exception handling, and functional iteration (map, where, fold, reduce, expand).
Asynchrony (36–43)
Future and the event loop, .then()/.catchError()/.whenComplete(), async/await and microtasks, Future.wait/Future.any, streams, single-subscription vs broadcast streams, stream transformers, and async/sync generators.
Packages and I/O (44–50)
pub.dev and lockfiles, file system I/O, HTTP clients, JSON serialization, code generation with build_runner and freezed, unit testing with package:test, and mocking with mockito and mocktail.
Concurrency and Memory (51–56)
Garbage collection (Scavenger and Mark-Sweep), the single-threaded concurrency model and microtask prioritization, isolates with Isolate.spawn, Isolate.run, bidirectional isolate communication, and typed data and native buffers.
Interop (57–61)
FFI with dart:ffi, structs and native memory, ffigen binding generation, dart:js_interop, and compiling to WebAssembly.
Reflection and Analysis (62–67)
dart:mirrors limitations and AOT alternatives, zones, advanced logging and trace collection, custom analyzer plugins, AST visitors for static analysis rules, and the macros framework.
Architecture (68–72)
Immutability with Equatable and Freezed union types, Clean Architecture in pure Dart, dependency injection with get_it and injectable, reactive state with streams and RxDart, and functional programming with fpdart.
Backend and Services (73–79)
CLI tools with package:args, web servers with package:shelf, middleware pipelines, WebSockets, gRPC microservices, Protocol Buffers, and ORMs and database connectors.
Performance and Security (80–86)
FFI vs native C benchmarks, profiling with DevTools, memory leak detection, tree shaking and AOT snapshot size, security practices, cryptography with package:crypto and package:encrypt, and dynamic code evaluators.
Tooling and Publishing (87–89)
Monorepos with melos, CI pipelines, and publishing to pub.dev.
VM Internals (90–96)
The Dart VM architecture and Kernel AST, class table layout and object headers, inline caches and polymorphic call sites, GC safepoints and mutator pauses, the AOT snapshot binary format, how async/await desugars into state machines, and dart2js vs dart2wasm.
Advanced Projects (97–100)
Building a custom transpiler or DSL parser, porting Node.js or Python utilities to Dart binaries, Dockerizing Dart backends, and hand-tracing the memory lifecycle from allocator to GC sweeper.
Chapter 101: The Cheatsheet
Why the VM Internals Matter
Chapters 90–100 are the reason to read this curriculum.
Most resources stop at "here's how async/await works." This one goes into how the VM executes your code—the Kernel AST, IL optimizations, inline caches, object headers, GC safepoints, and the AOT snapshot format.
That's what lets you diagnose a performance problem instead of guessing at const. It's the difference between using Dart and understanding it.
Beyond Flutter
Chapters 73–79 are unusual for a Dart curriculum. Most stop at the language. This one covers Dart as a backend language—CLI tools, shelf web servers, middleware pipelines, WebSockets, gRPC microservices, and ORMs.
Dart is not just Flutter's language. It runs standalone binaries, web servers, and command-line tools. This curriculum treats that as a first-class use case.
The Concurrency Section
Chapters 51–56 cover what most Dart developers never learn properly: the difference between the microtask queue and the event queue, how isolates communicate, and how the garbage collector actually works.
If you've ever had a Flutter app jank because of a heavy computation on the main isolate, this is where the solution lives.
Who This Is For
- Beginners: Start at Chapter 1 and read in order.
- Flutter developers: Jump to Chapter 51 (memory model) and read through Chapter 56 (isolates). Then Chapter 90 (VM internals).
- Backend developers: Start at Chapter 73 (CLI tools) and read through Chapter 79 (ORMs).
The Link
Free, no signup, 101 chapters.
If you've been writing Dart for Flutter but never understood how isolates work, or you're starting from scratch and want a path that doesn't stop at widgets, this is the most complete free curriculum I've found.
What Dart topics do you wish had better free resources? Let me know in the comments.
Top comments (0)