Mojo Complete Curriculum & Syllabus
Advance step-by-step through 10 structured progressive levels, taking learners from foundational core concepts to expert mastery. Explore the full syllabus below before enrolling.
Unlock All 10 Levels for Mojo
Get complete access to all modules, practical lessons, interactive quizzes, and advanced tracking tools designed to accelerate skill mastery.
Everything You Need to Succeed in Mojo
Our platform combines rigorous academic standards with engaging management tools built specifically to empower teachers, parents, and students alike.
Teacher/Parent Dashboard
Take complete control of education management. Assign seats, monitor overall group activity, and configure learning paths effortlessly from a centralized hub.
Student/Child Dashboard
An intuitive, distraction-free interface designed for learners. Easily navigate active lessons, pick up right where they left off, and view upcoming milestones.
Detailed Progress Reports
Never guess where a learner stands. Access granular analytics on quiz scores, module completion timelines, and skill proficiency gaps instantly.
Certificates of Completion
Celebrate academic milestones! Earn official, verifiable digital certificates with unique identification numbers upon mastering subject criteria.
Interactive Kanban Board
Organize daily study goals like a pro. Use our built-in drag-and-drop task workflow board to manage to-dos, assignments, and study schedules.
Star & Milestone Tracking
Keep motivation soaring high! Earn rewarding stars and precious gems for every correct answer and completed lesson to unlock achievements.
Comprehensive 10-Level Syllabus
Review the exact modules and learning milestones included inside every level of our Mojo program.
Mojo Ignition: Foundations & First Programs
Start from zero: what Mojo is, why it exists, the toolchain, your first programs, variables, core types, operators, control flow, functions and your first collections. No prior Mojo knowledge needed.
Included Modules (6)
Discover what Mojo is, why Modular built it, how it relates to Python, and run your very f...
Declare variables with var and master Mojo core types - Int, Float64, Bool and String - pl...
Teach programs to make decisions and repeat work with if/elif/else, while, for-in with ran...
Define your own building blocks: def vs fn, typed parameters, return values, default and k...
Organize data with tuples, List, Dict and Set, then meet struct - Mojo's blueprint for fas...
A 50-question capstone spanning every Level 1 topic: fundamentals, tooling, types, operato...
Mojo Deep Dive: Types, Strings & Collections Mastery
Consolidate the everyday toolkit: strings in depth, numeric types and conversions, the full List, Dict and Set workflows, and writing robust everyday Mojo code.
Included Modules (6)
Master everyday text work: literals and escapes, concatenation and conversions, finding an...
Get exact about numbers: how Int and Float64 behave, why 0.1 + 0.2 is not 0.3, floor divis...
Grow from list basics to real workflows: append and insert, pop and clear, index and membe...
Think in key-value pairs: creating typed Dict values, safe access with get and in, updatin...
Finish the toolkit: Set for uniqueness and fast membership, union, intersection and differ...
A 50-question capstone spanning every Level 2 topic: strings, numbers and conversions, Lis...
Mojo Architect: Structs, Methods & Custom Types Mastery
Move from using built-in types to designing your own: struct syntax and constructors, methods with self and mut self, dunder methods and operator overloading, structs that own collections, the @value decorator, and the design thinking that turns scattered variables into clean, reusable custom types.
Included Modules (6)
Build solid foundations for your own types: declaring structs with typed fields, writing _...
Give your types behavior: instance methods that read fields, mut self methods that change...
Make your types feel native: implement __add__ through the Add trait, unlock __sub__, __mu...
Combine everything so far: structs that own Lists, methods that manage and aggregate colle...
Think like a designer: model a bank account with rules, choose which values to store and w...
A 50-question capstone spanning every Level 3 topic: struct declarations and constructors,...
Mojo Engineer: Modules, Traits, Generics & Errors Mastery
Scale up from single files to real projects: organize code into modules and packages, declare your own traits and use the wider builtin trait family, write generic functions and parameterized structs, steer compile-time programming with @parameter, constrained and alias, handle failures gracefully with Error, raises and try/except, and take your first step into SIMD vectorized performance.
Included Modules (6)
Think beyond one file: what a module is, the import and from-import forms, packages and .m...
Move from consuming builtin traits to declaring your own: the trait keyword and method req...
Write code that works across types and runs before the program does: type parameters on fu...
Fail gracefully instead of crashing: the Error type and raise, the raises keyword and how...
Think in lanes: what SIMD is and why CPUs fly with it, constructing and reading SIMD value...
A 50-question capstone spanning every Level 4 topic: modules and imports, traits and confo...
Level 5 — The Standard Library: Files, CLI, Python Interop & SIMD
Step out of the language core and into real Mojo engineering. Master the import system and the math and random packages, read and write files, handle command-line arguments, bridge into the Python ecosystem, and meet the SIMD vector engine that powers Mojo performance. Six modules, 25 theory lessons with 250 explained questions, and a 50-question full practice test.
Included Modules (6)
Master the import system (modules, packages, local files), then put the math and random pa...
Talk to the outside world: receive command-line arguments through main(args) and sys, then...
Bridge Mojo and Python: import Python modules through Python.import_module, drive PythonOb...
Meet the SIMD type underneath every Float64: lanes, widths, splat construction, lane acces...
Combine everything from Levels 1-5 into five working tools: a file statistics analyzer, a...
A 50-question simulated exam covering every Level 5 module — standard library, files & CLI...
Level 6 — The Function Layer: Ownership, Variadics, Closures & Testing
Go under the hood of how Mojo moves data and proves code correct. Master the argument conventions (default immutable references, mut, var and the ^ transfer sigil, argument exclusivity and named results), write functions that accept any number of arguments with variadics and **kwargs, bundle behavior with data using closures and explicit capture lists, understand StaticString and non-owning views, and make your code trustworthy with the Mojo testing framework. Six modules, 25 theory lessons with 250 explained questions, and a 50-question full practice test.
Included Modules (6)
Learn exactly how Mojo passes values into functions: the default immutable reference, mut...
Write functions that accept any number of arguments: homogeneous variadics and the Variadi...
Bundle behavior together with data. Define closures with explicit capture lists (imm, mut,...
See how Mojo really stores data: the four memory segments, the String struct and its heap...
Make your code trustworthy: the Mojo testing framework and its assertion family (assert_tr...
A 50-question simulated exam covering every Level 6 module — argument conventions and owne...
Level 7 — The Hardware Layer: GPU, Async, FFI & Low-Level Mojo
Drop to the metal with Mojo. Drive accelerators with DeviceContext: allocate device buffers, enqueue kernels and copy results back, index threads, blocks and grids correctly, and always add bounds checks. Move up to shared memory, barriers, warp-level primitives, reduction and tiling patterns, and build real GPU performance sense — coalescing, divergence and occupancy. Structure programs that wait well with async functions, coroutines and await, and learn when asynchronous concurrency beats parallelism. Cross into the C world through the FFI: external_call, C number types and the ABI, shared libraries with OwnedDLHandle, foreign pointers, OpaquePointer and safe wrapper design. Then command raw bits and bytes: masks and flags, endianness with byte_swap, population counts, struct alignment and padding, and the intrinsics layer. Six modules, 25 theory lessons with 250 explained questions, and a 50-question full practice test.
Included Modules (6)
Meet the accelerator. Learn the host/device model, control a GPU with DeviceContext, write...
Go inside the block: fast on-chip shared memory and the barrier that coordinates it, warp-...
Programs that wait well: the async mental model, coroutines and await as first-class value...
Speak to the C world at full speed: why the C ecosystem matters and what an ABI is, callin...
Command the raw material: bit flags and masks for compact state, endianness and byte_swap...
The exam hall. Fifty exam-style questions across five parts — GPU foundations, warps/share...
Mojo Accelerator: Closures, Parallelism, GPU & Algorithms
Unlock the systems layer: closures with explicit capture lists, multicore parallelism with parallelize, GPU programming with DeviceContext and enqueued kernels, the testing and debugging toolkit, and a hands-on algorithms and data structures lab.
Included Modules (6)
Package behavior together with data: the capture list, immutable and mutable references, c...
Put every CPU core to work: the parallel mental model, spreading ranges across workers wit...
Step onto the GPU: the host-device model, DeviceContext and enqueued kernels, threads and...
Make it correct and keep it correct: the testing package, the assert family, assert_raises...
Build computer science from scratch in Mojo: Big-O analysis, stacks and queues, linear ver...
A 50-question capstone spanning every Level 8 topic: closures and capture lists, paralleli...
Mojo Frontier: Tensors, Kernels & Applied AI
Work with real data: the Tensor type, memory layouts and LayoutTensor, matrix-multiplication and softmax kernels, inference building blocks from activations to attention, and an applied project lab from convolution to a trained linear model.
Included Modules (6)
Meet the N-dimensional array at the heart of AI code: rank, shape and dtype, creating and...
Connect logical shape to physical memory: what layouts are, row_major versus col_major, La...
Build the workhorses of AI math: the matrix-multiplication contract, the naive triple-loop...
Assemble the pieces of real models: dot products and similarity, activation kernels, norma...
Put tensors to work end to end: image convolution, one-hot encoding, a mini linear regress...
A 50-question capstone spanning every Level 9 topic: tensor fundamentals, layouts and Layo...
Mojo Mastery: Performance Engineering & Production Systems
The mastery capstone: measure before optimizing, apply Amdahl's law and the roofline model, engineer data layouts for the cache hierarchy, tame floating-point precision, think in multi-device scaling, and ship production-grade libraries - sealed with a full 50-question practice test.
Included Modules (6)
Stop guessing, start measuring: a disciplined performance workflow, Amdahl's law and speed...
Structure data so the hardware likes it: cache lines and strided access, array-of-structs...
Floating point is a feature, not a bug - if you engineer it: how bits encode values, Float...
One device is never enough at scale: why single devices stop scaling, data parallelism and...
Turn code into products: APIs that age well, traits as contracts for library authors, docu...
The graduation exam: 50 mixed questions across performance analysis, cache-aware data engi...
Frequently Asked Questions
Everything you need to know about enrolling and learning Mojo on WordThesauri.
How are the 10 progressive levels structured for Mojo? +
Every subject is broken down into 10 structured levels moving systematically from foundational basics to expert proficiency, featuring modular units and interactive practice lessons.
Can I track my child or student’s progress in real-time? +
Yes! The Teacher/Parent Dashboard provides detailed progress reports, star & milestone tracking, and completion analytics for every student.
Is the first lesson of Mojo really free? +
Yes. The first lesson is completely free to try. Every other lesson shows Upgrade to learn until you enroll in the full annual subscription.
How does the student seat pricing work for classrooms or families? +
You can purchase licenses per student seat on an annual subscription basis. Each student receives their own dedicated dashboard, rewards, and Kanban task board.
Are certificates awarded upon completing the course? +
Yes, students earn official Certificates of Completion as they conquer modules and milestones across the curriculum.
Why Choose WordThesauri for Mojo Mastery?
Welcome to WordThesauri premier online learning track for Mojo. Built specifically for independent learners, homeschoolers, and classroom educators, our curriculum breaks down complex topics into 10 structured, bite-sized progressive levels.
Structured for Permanent Skill Retention
Every level features carefully curated modules and practice lessons equipped with step-by-step worked solutions, real-time analytics, and milestone rewards. Whether you are starting from absolute fundamentals or advancing toward expert proficiency, our interactive platform guarantees steady academic growth.
Flexible Enrollment & Group Pricing
Parents and teachers can easily scale seats across multiple students using our annual subscription model, complete with dedicated child dashboards, printable certificates of completion, and automated progress reports. Try the first lesson for free today!