Learn
Choose your path
Start with a general computer-science tour, trace the ML family, or dive into a single language.
General Computer Science
A from-scratch CS tour that constantly detours to show how Guji and its six companion languages (Go, OCaml, Perl, Raku, Rust, Python) each answer the same core questions - bindings, functions, types, sum types, errors, text, and concurrency.
The ML Family
The story of ML: Robin Milner's meta-language for the LCF theorem prover, the birth of Hindley-Milner type inference, and the algebraic-data-type-plus-pattern-matching paradigm that travelled through Standard ML and OCaml into Rust, Guji, and the wider world.
Learn Guji
Guji is an in-house, compiled, statically-typed, functional-first language whose signature capability is first-class text processing: regular-expression literals and PEG **grammars** are part of the language, not a library. Every binding wears an invariant Perl/Raku-style sigil (`$` scalar, `@` list, `%` map), bindings are immutable by default, types are inferred, and a program compiles ahead-of-time to a single self-contained native binary. As of v0.1-alpha the toolchain ships both a reference tree-walking interpreter and a native AOT compiler, kept byte-identical by a differential test gate; platform IO (stdin/stdout/stderr, files, CLI args), CSP concurrency (`hatch`, channels), and generics are all implemented. This track teaches Guji from the ground up - toolchain, syntax and types, functions and uniform call syntax, collections, `Option`/`Result` error handling, platform IO, the regex-and-grammar text engine that is its reason to exist, and the real concurrency model. Every code sample here was run against the v0.1-alpha reference toolchain.
Learn Go
Go (often called Golang) is a statically typed, compiled language created at Google by Robert Griesemer, Rob Pike, and Ken Thompson, first released in 2009 and at version 1.26 as of February 2026. It was designed for simplicity, fast compilation, and concurrency: a small, readable syntax; a powerful standard library; built-in tooling (go build, go test, gofmt); and lightweight goroutines and channels that make concurrent programs easy to write. This track teaches Go from the ground up - installing the toolchain, the type system, functions and interfaces, slices and maps, idiomatic error handling, concurrency, and the module-based ecosystem - with runnable examples and links to the official docs at go.dev.
Learn OCaml
OCaml is a practical, industrial-strength functional language with a famously strong static type system, full type inference, algebraic data types, and exhaustive pattern matching. It compiles to fast native code, has a REPL for exploration, and ships with first-class modules and a powerful module system. OCaml 5 added shared-memory parallelism via domains and the first mainstream implementation of effect handlers. This OCaml track walks you from a working toolchain (opam + dune) through types, functions, collections, robust error handling, and OCaml 5's concurrency story, ending with the everyday ecosystem you will actually use. Every lesson links to the official docs so you can go deeper.
Learn Haskell
Haskell is a pure, lazy, statically typed functional language born in 1990 and named after the logician Haskell Curry. It pairs Hindley-Milner type inference with a rich type-class system, algebraic data types, and pattern matching, so programs read like precise mathematical definitions yet compile to fast native code through GHC. Purity means functions have no hidden side effects, and effects such as input and output are modeled explicitly with types like IO, Maybe, and Either. Laziness lets you describe infinite structures and only pay for what you consume. The result is concise, composable code that often expresses an idea in fewer lines than imperative languages, while the compiler catches large classes of mistakes before the program ever runs.
Learn Perl
Perl is a battle-tested, high-level, dynamic language created by Larry Wall in 1987 and famous for its expressive text-processing power, its motto "There's More Than One Way To Do It," and the vast CPAN module archive. This track teaches modern Perl 5 (version 5.40, released June 2024) the way it is written today: with `use v5.40` turning on strict mode, warnings, subroutine signatures, and a clean built-in toolkit. You will set up the toolchain, master scalars, arrays, hashes and references, write subroutines with real signatures, wield Perl's legendary regular expressions, handle errors with native `try`/`catch`, build objects with the new core `class` syntax, and learn your way around CPAN. Like Guji and Python, Perl rewards you for running code early and often, so every lesson here is verified working code you can paste into a file and execute.
Learn Raku
Raku (formerly Perl 6, renamed in 2019) is a gradually typed, multi-paradigm member of the Perl family, designed by Larry Wall and developed over many years as a clean-slate sister language to Perl. Its reference compiler, Rakudo, runs on the MoarVM virtual machine and implements the Raku 6.d language specification, with new releases roughly monthly. Raku is expressive and unusually feature-rich: a sigil-based variable system, arbitrary-precision and rational numbers, Unicode-correct strings, lazy and infinite lists, multiple dispatch, an introspectable object model with composable roles, first-class grammars for parsing, and high-level concurrency built on promises, supplies, and react/whenever. This track teaches Raku from the ground up - installing Rakudo and zef, variables and gradual typing, subroutines and signatures, collections and lazy pipelines, exceptions and soft failures, concurrency, classes and grammars, and packaging modules for the ecosystem - with runnable examples and links to the official docs at docs.raku.org.
Learn Rust
Rust is a systems programming language that delivers memory safety and data-race freedom without a garbage collector, using a compile-time ownership and borrowing model that the compiler verifies before your program ever runs. First released 1.0 in 2015 and stewarded today by the Rust Foundation, it has reached version 1.96 by June 2026 and is organized into backward-compatible editions, the latest being Rust 2024. Rust pairs low-level control (no runtime, predictable performance, C-compatible FFI) with high-level ergonomics: algebraic data types, exhaustive pattern matching, traits, generics, and a rich iterator-based standard library. Its tooling is famously cohesive - one tool, cargo, builds, tests, formats, lints, and publishes - and its compiler errors are designed to teach. This track takes you from installing the toolchain through ownership, the type system, error handling, collections and iterators, fearless concurrency, and the cargo ecosystem, with runnable examples and links to the official docs at rust-lang.org.
Learn Python
Python is a dynamically typed, garbage-collected, multi-paradigm language created by Guido van Rossum and first released in 1991. It prizes readability above almost everything else: significant indentation instead of braces, a small set of orthogonal constructs, and a culture summarized in the Zen of Python ('readable counts'). The current feature release is Python 3.14, shipped on 7 October 2025, which made the free-threaded (no-GIL) build officially supported and added template strings, deferred annotations, and a tail-call interpreter. This track teaches Python from the ground up for the Eulingua reader who already knows another language such as Guji or Go: installing the interpreter and setting up tooling, the syntax and dynamic type system, functions and the many ways to pass arguments, the four core collection types, idiomatic error handling with exceptions and exception groups, concurrency with asyncio and threads, and the packaging ecosystem around pip, venv, and uv. Every example here was run against a real CPython interpreter, and every lesson links to the official documentation at docs.python.org.