Skip to content
ZOLO / DOCS

The Zolo language guide

Choose a guided path, jump straight into executable code, or use the map as a precise reference. Your reading progress stays with you.

ZOLO / Reference

Read by subject

Start with values and functions, then move on to types, errors, concurrency and effects.

Learn through examples Language integrations
01

Choose how you want to learn

There is no single right order. Start with feedback from real code, follow a guided sequence, or look up exactly what you need.

01

5 min · no install

Make the language move

Edit and run a real Zolo program in the browser, with compiler output beside the source.

Open the Playground
02

Step by step

Build a mental model

Follow short lessons that introduce one idea at a time and turn each concept into a small exercise.

Start the tutorial
03

Look up & return

Find the exact concept

Use the complete language map when you already know the question and need a precise, connected answer.

Read the introduction
02

The complete learning map

Seven connected regions take you from the first program to the runtime, the web stack, and the language reference.

01

Getting Started

Understand the language's shape, run your first program, and set up the daily development loop.

  1. 01 Introduction Zolo's current identity: many references, one coherent model, one toolchain, and several destinations.
  2. 02 Getting Started Install the toolchain, create a project, develop in watch mode, and choose a build destination.
02

Fundamentals

Learn the syntax and data model you will use in almost every Zolo program.

  1. 03 Variables & Types let, const, mut and Zolo's type system.
  2. 04 Operators Pipe |>, optional chaining ?., null coalesce ?? and more.
  3. 05 Strings Interpolation, multiline strings and tagged templates.
  4. 06 Control Flow if/else, match, for, while and loop.
  5. 07 Conditions and error recovery Conditions, collection entries, comparison chains and Result boundaries.
  6. 08 Data Structures Structs, enums, traits, arrays and maps.
  7. 09 Records, maps and updates Records, maps, projections and reusable field paths.
  8. 10 Functions Functions, closures, generators and async functions.
  9. 11 Function parameters and lambdas Lambdas, labels, callback blocks and pattern clauses.
03

Modules and reusable code

Use patterns, decorators, generators, modules and macros to organize and reuse code.

  1. 12 Pattern Matching Exhaustive match, destructuring and guards.
  2. 13 Decorators @memoize, @test, @benchmark, @retry and @log.
  3. 14 Deriving and named tests Shared derive producers and test titles preserved by the runner.
  4. 15 Generators Generator functions with fn* and yield for lazy sequences.
  5. 16 Modules & Visibility Organize code with `mod` (file or inline block), bring names into scope with `use`, alias them with `as`, import the module table itself with `self`, and choose the right visibility from `pub` to `pub(crate)`, `pub(super)`, or `pub(mod)`.
  6. 17 Macros Hygienic macros, parameters, stringify! and compile-time expansion.
04

Advanced

Understand fallibility, concurrency, effects, compile time, and advanced types.

  1. 18 Error Handling Result, ?, try/catch/finally, panic and guard for robust error handling.
  2. 19 Advanced Types Generics, type aliases, newtypes, as/is and associated types.
  3. 20 Validation, schemas and units Validated values, typed captures, schemas and dimensional units.
  4. 21 Advanced Control Flow defer, let-else, while let, guard, loop with value and ranges.
  5. 22 Typed states and events Typed events and state witnesses that constrain transitions.
  6. 23 Async & Concurrency async/await, spawn and every for asynchronous and concurrent programming.
  7. 24 Parallel tasks and deadlines Named parallel results, await deadlines and lazy delegation.
  8. 25 Algebraic Effects Declarative dependency injection: declare what your function needs, decide on the edges. Beats DI containers, mocks, monads and async/await viral.
  9. 26 Handlers and resource scopes Lexical handlers, typed overrides and deterministic resource cleanup.
  10. 27 Comptime Filesystem Read files at compile time with std::fs and bake them into the bytecode as literals — same API as runtime, prefixed by `comptime`. Inspired by Zig's @embedFile and Rust's include_str!.
  11. 28 Float Precision & Decimal Types Comparing floats safely with `~=`, plus the `decimal` and `bigdecimal` exact types.
05

Web & Verniz

Build server-rendered and interactive web applications with HTTP and Verniz.

  1. 29 Web Development Build full-stack applications with std::http, std::web and Verniz, from a rendered View to a production binary.
  2. 30 Verniz Views & Markup Components as functions, HTML-like markup, safe interpolation and server-rendered Views without a template language.
  3. 31 Islands, Signals & Actions Add focused interactivity with @island, signal storage, DOM events, bindings and server actions.
  4. 32 Scoped CSS Write component-scoped style blocks, global CSS and reactive custom properties with compiler diagnostics.
  5. 33 Development Workflow Use zolo dev, hot everything, browser revalidation and production builds across the VM, LLVM and Cranelift.
  6. 34 Components & Typed DOM Use concise props, typed child blocks, associated server actions, native DOM checking, forwarding, refs, portals and boundaries.
  7. 35 Runtime & Deploy Build sealed static, hybrid and server products with reproducible runtime artifacts, content-addressed caching and provider-neutral deployment.
  8. 36 Navigation & Prefetch Accelerate ordinary multi-page links with WebGraph-derived intent prefetch, byte-bounded caching and optional View Transitions.
  9. 37 Verniz Sites production guide Build, inspect, test and deploy complete static, hybrid and server products with TypeScript, packages, content and auditable graphs.
06

Libraries, integrations and tools

Work with the standard library, databases, HTTP, the CLI, the editor, and the toolchain.

  1. 38 Standard Library String, Array, Map, Set, Iter, Option, Result and BigInt.
  2. 39 Programming language integrations Ten languages, seven provider families, real runtimes and deployment requirements.
  3. 40 Types across language boundaries Exact integers, copied records, live objects, callbacks and async conversion.
  4. 41 Foreign dependencies and locks One dependency declaration with explicit installation, frozen and offline policies.
  5. 42 HTTP Server Router, middleware, path params, JSON and pipe-based composition.
  6. 43 Database SQLite, SQL transpilation, query, execute and connection management.
  7. 44 Tooling CLI, LSP, DAP debugger, formatter and VS Code extension.
07

Reference

Keep concise examples, the cheat sheet, and the compiler architecture within reach.

  1. 45 Complete Examples Complete programs written in Zolo.
  2. 46 Cheatsheet Quick reference for all Zolo syntax.
  3. 47 Architecture Compiler pipeline, crates and internal architecture.

Global index

Find your way through Zolo

Try an idea

Start here

9 results

9 results
enespt-br