{ "version": "v1", "pages": [ { "title": "404 - Page not found", "path": "404.html", "content": "404 - Page not found Skip to content Vitte Welcome Documentation Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Page not found The page does not exist or was moved. Use the links below or search the docs. Home Documentation Sitemap Status 404.html Back to home", "lang": "en", "section": "docs" }, { "title": "Vitte Native Bootstrap Migration (Rust-style)", "path": "BOOTSTRAP_NATIVE_MIGRATION_FROM_RUST.html", "content": "Vitte Native Bootstrap Migration (Rust-style) Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Vitte Native Bootstrap Migration (Rust-style) Reference model: bootstrap builder graph semantics (step contracts, strict stage semantics). Target Architecture toolchain/src/bootstrap_vitte/mod.vit Global context (paths, host/target, budgets, report sinks). toolchain/src/bootstrap_vitte/core/build_steps/mod.vit Step contract ( name , deps , run , artifacts , invariants ). toolchain/src/bootstrap_vitte/core/builder/mod.vit Deterministic DAG executor with fail-fast semantics. toolchain/src/bootstrap_vitte/core/sanity/mod.vit Reproducibility, contract interface, parity, corpus diagnostics, performance budgets. toolchain/src/bootstrap_vitte/utils/metrics.vit JSON report writer to target/reports/bootstrap/*.json . toolchain/src/bootstrap_vitte/main.vit CLI entrypoint, routes to full hard gate or scoped runs. Migration Phases Phase A (coexist) Keep current scripts and Make targets. Add bootstrap-v2-hard-gate target invoking strict hard gate. Phase B (step parity) Re-encode existing stages as typed Step objects. Ensure exact behavioral parity with current bootstrap-hard-gate . Phase C (ownership switch) Make bootstrap-v2-hard-gate the release gate. Keep legacy flow for rollback for 1 release cycle. Non-negotiable Invariants Fail-fast on first error. No silent fallback in release/hard mode. Stage artifacts hash-identical for reproducibility checks. Stage interface contract snapshots are diff-blocking. Bootstrap parity and corpus diagnostics are release-blocking. CI Matrix macOS: x86_64 , arm64 Linux: x86_64 , arm64 Same invariants and JSON report shape on all runners. Entry Commands Local hard gate: make bootstrap-hard-gate Future native hard gate: make bootstrap-v2-hard-gate Reports: target/reports/bootstrap/hard_gate.json ← Previous Next → BOOTSTRAP_NATIVE_MIGRATION_FROM_RUST.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Bootstrap Vitte File Mapping", "path": "BOOTSTRAP_VITTE_FILE_MAPPING.html", "content": "Bootstrap Vitte File Mapping Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Bootstrap Vitte File Mapping Source reference: reference-bootstrap-vitte Top-level reference-bootstrap-vitte:src/bootstrap/src/lib.rs -> toolchain/src/bootstrap_vitte/mod.vit reference-bootstrap-vitte:src/bootstrap/src/bin/main.rs -> toolchain/src/bootstrap_vitte/bin/main.vit reference-bootstrap-vitte:src/bootstrap/src/bin/compiler_frontend.rs -> toolchain/src/bootstrap_vitte/bin/compiler_frontend.vit reference-bootstrap-vitte:src/bootstrap/src/bin/docgen.rs -> toolchain/src/bootstrap_vitte/bin/docgen.vit reference-bootstrap-vitte:src/bootstrap/src/bin/cache-plus-cl.rs -> toolchain/src/bootstrap_vitte/bin/cache_bridge.vit core/ core/builder/mod.rs -> core/builder/mod.vit core/builder/cargo.rs -> core/builder/cargo.vit core/builder/tests.rs -> core/builder/tests.vit core/config/mod.rs -> core/config/mod.vit core/config/flags.rs -> core/config/flags.vit core/config/manifest/mod.rs -> core/config/manifest/mod.vit core/config/manifest/compiler_profile.rs -> core/config/manifest/compiler_profile.vit core/build_steps/mod.rs -> core/build_steps/mod.vit core/build_steps/compile.rs -> core/build_steps/compile.vit core/build_steps/test.rs -> core/build_steps/test.vit core/build_steps/doc.rs -> core/build_steps/doc.vit core/build_steps/dist.rs -> core/build_steps/dist.vit core/build_steps/clean.rs -> core/build_steps/clean.vit core/build_steps/install.rs -> core/build_steps/install.vit core/build_steps/check.rs -> core/build_steps/check.vit core/build_steps/clippy.rs -> core/build_steps/clippy.vit core/build_steps/format.rs -> core/build_steps/format.vit core/build_steps/llvm.rs -> core/build_steps/llvm.vit core/build_steps/run.rs -> core/build_steps/run.vit core/build_steps/setup.rs -> core/build_steps/setup.vit core/build_steps/suggest.rs -> core/build_steps/suggest.vit core/build_steps/tool.rs -> core/build_steps/tool.vit core/build_steps/vendor.rs -> core/build_steps/vendor.vit core/download.rs -> core/download/mod.vit core/metadata.rs -> core/metadata/mod.vit core/sanity.rs -> core/sanity/mod.vit utils/ utils/mod.rs -> utils/mod.vit utils/build_stamp.rs -> utils/build_stamp.vit utils/cache.rs -> utils/cache.vit utils/channel.rs -> utils/channel.vit utils/change_tracker.rs -> utils/change_tracker.vit utils/exec.rs -> utils/exec.vit utils/helpers.rs -> utils/helpers.vit utils/job.rs -> utils/job.vit utils/metrics.rs -> utils/metrics.vit utils/render_tests.rs -> utils/render_tests.vit utils/tarball.rs -> utils/tarball.vit Status mapped : path exists stub : created placeholder API, implementation pending implemented : non-trivial logic ported ← Previous Next → BOOTSTRAP_VITTE_FILE_MAPPING.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Compiler Driver Alignment", "path": "COMPILER_DRIVER_MIGRATION.html", "content": "Compiler Driver Alignment Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Compiler Driver Alignment HTML reading page generated from the source Markdown document. Documentation Source Sitemap Source Markdown Reading mode This page is the static HTML reader for COMPILER_DRIVER_MIGRATION.md . Internal Markdown links are rewritten to HTML when a matching reading page exists. Compiler Driver Alignment This document tracks the Vitte-owned compiler driver surface after the host driver migration. Overview The driver remains a first-class subsystem because it defines the stable command entrypoints that users, CI, bootstrap flows, and documentation all depend on. Concern Current contract Surface ownership src/vitte/packages/compiler/driver/* catalogs Runtime implementation src/vitte/compiler/driver/* Audit goals parity, normalization, stage mapping Enforcement dedicated make targets and strict gates Why the driver stays explicit: it defines the user-visible command surface it isolates option parsing and command dispatch from frontend/backend internals it gives CI a small, deterministic place to audit command and flag parity Responsibilities Own the visible command and flag inventory. Normalize aliases and stage names consistently. Keep package metadata and runtime implementation aligned. Invariants Command catalogs and implementation must not drift silently. Normalization rules must stay deterministic. Strict gates must detect driver regressions before release-facing changes land. Current Surface The Vitte package lives in: src/vitte/packages/compiler/driver/mod.vit src/vitte/packages/compiler/driver/info.vit src/vitte/packages/compiler/driver/internal/command_catalog.vit src/vitte/packages/compiler/driver/internal/option_catalog.vit src/vitte/packages/compiler/driver/internal/normalize.vit This package now owns: command catalog metadata top-level command inventory grammar/mod subcommand inventory flag inventory parity against the Vitte driver catalogs normalization of help aliases normalization of selected command and flag aliases stage mapping for normalized commands Data Flow User input enters through the top-level driver command surface. Package catalogs normalize commands, aliases, and selected option values. The runtime driver maps the normalized request to compiler stages. Strict audits verify that the exposed help and command behavior still match the owned catalogs. Driver Implementation The compiler driver implementation is split between the public entry facade and the runtime driver core: src/vitte/compiler/main.vit src/vitte/compiler/driver/compile.vit src/vitte/compiler/driver/compiler.vit src/vitte/compiler/driver/mod.vit src/vitte/compiler/main.vit is the real compiler entrypoint used by bootstrap and packaging flows. src/vitte/compiler/driver/compiler.vit remains the runtime command dispatcher and stage-mapping core behind that facade. Audit And Bootstrap Commands make driver-surface-audit make driver-surface-parity make selfhost-driver-bootstrap Pipeline The driver sits ahead of the compiler pipeline proper. Its job is to convert CLI surface into a precise compiler action before frontend, analysis, or backend work begins. Examples make driver-surface-audit make driver-surface-parity ./bin/vitte --help ./bin/vitte check src/app.vit Next Step Keep option value normalization aligned across the driver package and compiler driver: --template --lang --target --stage --stdlib-profile --syntax-profile --panic-budget --strict-recovery That keeps the command surface deterministic while the rest of the compiler continues moving through the Vitte source tree. 2026-05-20 Strict Gate Update Latest strict alignment pass added concrete enforcement around the driver path: make compiler-entry-lock enforces COMPILER_SOURCE_ROOT=src/vitte/compiler enforces COMPILER_ENTRY_POINT=src/vitte/compiler/main.vit make compiler-reachability-audit checks transitive module reachability from vitte/compiler/main allows temporary migration exceptions through a tracked allowlist make compiler-max-gate-strict compiler-focused strict gate (frontend/analysis/middle/backend checks + strict smokes) make selfhost-hard-strict end-to-end release gate chain for bootstrap + strict compiler path The current migration objective remains unchanged: reduce reachability allowlist to zero complete diagnostics path migration ( dignostics -> diagnostics ) keep strict gates green without hidden fallback behavior 2026-05-20 Stop-After And Repro Hardening Additional strictness landed on the same date: Driver --stop-after is now treated as a hard runtime contract: stage mapping is centralized in src/vitte/compiler/driver/compiler.vit successful stop no longer rewrites final stage to Done exact stop tests now cover parse/hir/typeck/mir/ir/codegen/link/run Driver diagnostic propagation now uses typed fields end-to-end in the driver mapping la", "lang": "en", "section": "docs" }, { "title": "CONTRIBUTING", "path": "CONTRIBUTING.html", "content": "Contributing to Vitte Thank you for your interest in contributing to Vitte. Overview Vitte is an open-source programming language project including: * Compiler * Standard Library * Tooling * Documentation * Editor Integrations * Build Infrastructure * Tests and Benchmarks All contributions are welcome. Ways to Contribute You can contribute through: * Bug reports * Feature requests * Documentation improvements * Standard library additions * Compiler development * Tooling improvements * Tests * Performance optimizations * Editor extensions Before Starting Please: 1. Search existing issues. 2. Check open pull requests. 3. Discuss major changes before implementation. 4. Keep changes focused and well documented. Development Setup Clone the repository: git clone https://github.com/vitte-lang/vitte.git cd vitte Build: make Run tests: make test Run formatting and validation: make fmt make lint Coding Standards General * Prefer readability. * Keep functions focused. * Avoid unnecessary complexity. * Write deterministic code whenever possible. * Add comments only when they improve understanding. Compiler * Follow existing compiler architecture. * Preserve diagnostic quality. * Maintain deterministic outputs. * Add tests for every new feature. Standard Library * APIs should be consistent. * Documentation is required. * Public APIs should remain stable. * Include usage examples. Documentation Documentation changes should: * Use clear language. * Include examples. * Explain edge cases. * Stay synchronized with implementation. Testing Every contribution should include appropriate tests. Examples: * Unit tests * Integration tests * Regression tests * Parser tests * Semantic analysis tests * Backend tests Bug fixes should include a regression test whenever possible. Commit Messages Recommended format: component: short summary Detailed explanation of the change. Examples: parser: improve generic type parsing borrowck: fix invalid lifetime propagation stdlib/fs: add recursive directory traversal Pull Requests Before opening a pull request: * Ensure the project builds successfully. * Ensure tests pass. * Update documentation. * Add new tests if required. * Keep pull requests focused. Pull Request Checklist * Builds successfully * Tests pass * Documentation updated * No unrelated changes * Commit history cleaned up Reporting Bugs Please include: * Vitte version * Operating system * Architecture * Reproduction steps * Expected behavior * Actual behavior * Relevant logs Feature Requests Please describe: * The problem being solved * Proposed solution * Alternative approaches * Potential impact Code of Conduct Be respectful and constructive. Harassment, personal attacks, discrimination, and disruptive behavior are not tolerated. License By contributing to Vitte, you agree that your contributions will be licensed under the project’s license. Thank you for helping improve Vitte.", "lang": "en", "section": "docs" }, { "title": "Make Targets", "path": "MAKE_TARGETS.html", "content": "Make Targets Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Make Targets This page indexes the most useful make entrypoints. Overview Area Purpose Beginner / Local Loop short local iteration and basic health checks Core Language grammar and core compiler contract gates Documentation docs generation, rendering, and validation flows Modules / Stdlib module graph, snapshots, and package governance CI / Reports consolidated repo-wide gates and reporting targets VitteOS operating-system oriented checks and CI chains Packaging install and release packaging targets Responsibilities provide a curated index of the most useful repository entry points keep target names aligned with make help output make documentation, CI, packaging, and local loop targets easy to find Invariants this page is generated from make help and should not drift from it the curated sections should remain stable even as descriptions evolve readers should be able to find the primary bootstrap and driver-related targets quickly Data Flow make help defines the source descriptions. tools/generate_make_targets_doc.py extracts and groups the selected targets. docs/MAKE_TARGETS.md is regenerated from that grouped view. Bootstrap Bootstrap-oriented targets live mostly in make help ; this page points to the most useful top-level documentation and validation commands around them. Driver Driver-related targets are surfaced here when they are part of the curated local, CI, or documentation workflow. For the full list, run: make help Beginner / Local Loop make build : everything make quickstart-check : verify the beginner path against examples/first_project.vit make doctor : print local toolchain and environment readiness make test : run tests (std/test) make parse : run parser-level tests make hir-validate : run HIR validator test fixtures Core Language make grammar-check : fail if grammar generated artifacts are out of sync make grammar-gate : run grammar-check + grammar-test make core-language-gate : run grammar-check + core-language-test + core semantic gates + lint local diagnostics make core-release-gate : run the protected language contract gate for release-facing work Documentation make docs-phase1-smoke : run full docs pipeline phase1 + local index/news/community style smoke make docs-maximal : run the full documentation generation + validation pipeline (default PHASE=phase3) make site-html : regenerate sibling HTML pages in English under docs/ make book-qa-strict : run strict book QA checks Modules / Stdlib make modules-tests : run module graph/doctor fixtures make modules-snapshots : assert mod graph/doctor outputs make modules-contract-snapshots : assert modules contract snapshots make packages-gate : run package governance/layout/perf/contract gate CI / Reports make ci-fast : run fast CI chain for language/compiler snapshots and checks make ci-strict : run strict CI chain with additional diagnostics/highlight checks make ci-completions : run completion check + lint + snapshots + fallback make repo-hygiene-check : verify root-level repository hygiene constraints make docs-paths-check : verify README/docs local path references exist make dx-adoption : run DX/adoption quality gates make public-benchmark-dashboard : generate publication dashboard + KPI (3/3 use cases) make release-proof-notes : generate proof-oriented release notes + tag candidate make all-tests : run full grouped test inventory make reports-index : build target/reports/index.json (unified reports registry) make release-doctor : run the snapshot/release readiness report continued VitteOS make vitteos-doctor : print VitteOS environment diagnostics make vitteos-quick : run quick local loop (issues + domain + orphan + space + arch-contract + header + targeted + smoke) make vitteos-ci : run VitteOS CI chain (soft scripts + bin gate + issues + domain + orphan + space + arch-contract + header + targeted + smoke + adr) make vitteos-ci-strict : run strict VitteOS CI chain (strict scripts + bin gate + issues + domain orphan + space + arch-contract + header + targeted + smoke + adr) Packaging make pkg-debian : build Debian .deb installer (PACKAGE_PROFILE=full, PKG_VERSION=0.1.0) make pkg-debian-audit : audit generated Debian .deb content and largest files make pkg-macos : build macOS install pkg (PKG_VERSION=0.1.0) make macos-universal-bin : build target/universal/vitte (arm64 + x86_64 via lipo) make pkg-macos-universal : build macOS universal installer pkg (vitte-0.1.0-universal.pkg) make release-check : run build + core-release-gate + ci-fast + ci-completions + pkg build ← Previous Next → MAKE_TARGETS.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Migration Markdown", "path": "MD_MIGRATION.html", "content": "Migration Markdown Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Markdown migration The public documentation flow is now HTML-first. Markdown remains in the repository as the editable source for selected operational guides and internal reference pages. What changes Public home pages use simple HTML tables and sections. Reader-facing links now prefer the HTML page whenever a matching static document exists. Source-backed guides are grouped under source-guides.html . Navigation remains organized around docs/book , doc.html , and the source guides hub. What doesn't change The structure of the sections remains the same. The book reading paths remain unchanged. Diagnostics and technical documentation remain accessible to the same content. Each generated reader page still exposes its original Markdown source. Entry point Documentation Welcome Source-backed guides ← Previous Next → MD_MIGRATION.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Compiler Module Reference", "path": "MODULE_REFERENCE.html", "content": "Compiler Module Reference Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Compiler Module Reference HTML reading page generated from the source Markdown document. Documentation Source Sitemap Source Markdown Reading mode This page is the static HTML reader for MODULE_REFERENCE.md . Internal Markdown links are rewritten to HTML when a matching reading page exists. Compiler Module Reference The canonical compiler entry is src/vitte/compiler/main.vit . It delegates CLI execution to src/vitte/compiler/driver/compiler.vit and the driver pipeline. Frontend src/vitte/compiler/frontend/lexer/ : tokenization. src/vitte/compiler/frontend/parse/ : parsing and recovery. src/vitte/compiler/frontend/ast/ : syntax tree definitions and helpers. src/vitte/compiler/frontend/macros/ : macro-facing frontend support. Analysis And Middle End src/vitte/compiler/analysis/sema/ : semantic analysis. src/vitte/compiler/analysis/typeck/ : type checking. src/vitte/compiler/analysis/borrowck/ : borrow checking. src/vitte/compiler/analysis/const_eval/ : constant evaluation. src/vitte/compiler/middle/hir/ : high-level IR. src/vitte/compiler/middle/mir/ : mid-level IR. src/vitte/compiler/middle/lower/ : lowering passes. src/vitte/compiler/middle/passes/ : middle-end pass orchestration. IR And Backends src/vitte/compiler/ir/ : compiler IR contracts and transformations. src/vitte/compiler/backend/ : target, code generation, linker, and backend interfaces. src/vitte/compiler/backends/ : concrete runtime C, Vitte emit, WebAssembly, and LLVM binding surfaces. src/vitte/compiler/optimizations/ : optimization passes. Driver And Infrastructure src/vitte/compiler/driver/pipeline.vit : pipeline orchestration. src/vitte/compiler/driver/pipeline_modular.vit : modular pipeline support. src/vitte/compiler/driver/compile.vit : compile request execution. src/vitte/compiler/driver/commands.vit : command handling. src/vitte/compiler/diagnostics/ : compiler diagnostics. src/vitte/compiler/infrastructure/ : sessions, incremental state, distribution, and diagnostic infrastructure. Validation make compiler-architecture-check make compiler-real-pipeline-audit make compiler-test-suite-check-gate make compiler-test-suite-bridge-gate Generated architecture reports live under target/reports/ ; they are evidence for a specific run, not source-of-truth modules. ← Previous Next → MODULE_REFERENCE.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Package Index", "path": "PACKAGE_INDEX.html", "content": "Package Index Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Package Index This file maps package families to their main repository anchors. Use Package Maturity for the maturity policy. Use this file when you need the practical index of facades, metadata, docs, and API pages. Package Default maturity Facade Metadata Owners Docs API index compiler internal-by-default - - - - - Reading Rule documented-experimental means visible public surface, but still expected to change unless explicitly promoted internal-by-default means the package exists in the repository, but should not be treated as a public promise just because it is present ← Previous Next → PACKAGE_INDEX.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Package Maturity", "path": "PACKAGE_MATURITY.html", "content": "Package Maturity Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Package Maturity This page defines the maturity labels used by Package Index . Labels documented-experimental : visible public surface with documentation, but still expected to change until explicitly promoted. internal-by-default : repository-local package surface that should not be treated as a public compatibility promise. Rule Packages are internal by default. A package becomes documented experimental only when it has an intentional docs or API index entry and is listed by the package index generator. ← Previous Next → PACKAGE_MATURITY.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Release Notes Template", "path": "RELEASE_NOTES_TEMPLATE.html", "content": "Release Notes Template Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Release Notes Template Use this template when publishing a Vitte release note entry in the website, changelog, or release bundle. Release Metadata Version: X.Y.Z Release date: YYYY-MM-DD Publication reference: tag / commit / signed attestation Release channel: stable | rc | beta | nightly Summary Short description of the release and the user-visible reason it exists. Artifacts Install package: Uninstaller package: Tarball or archive: Checksums: Signature or notarization status: Included Components vitte vittec Toolchain runtime Manpages Shell completions Editor assets Add or remove entries to match the actual payload. Highlights Item 1 Item 2 Item 3 Compatibility Minimum supported upgrade path: Bootstrap or seed impact: Platform support: Known incompatible changes: Cross-check this section against docs/release/compatibility_matrix.md . Migration Notes Required config changes: Required workflow changes: Optional cleanup after upgrade: Fixed Compile: Driver/CLI: Toolchain: Docs: Packaging: Known Issues Issue: Workaround: Verification Checklist make release-check make release-doctor package audit completed uninstall flow reviewed compatibility matrix reviewed Publication Checklist download page updated changelog updated release notes embedded in release bundle if required artifact names and versions verified ← Previous Next → RELEASE_NOTES_TEMPLATE.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Support", "path": "SUPPORT.html", "content": "Support Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Support Where to look when a build, diagnosis, or migration question does not fit the main docs. Sitemap Diagnostics Community Start here Diagnostics Documentation Source Escalation path Reproduce the issue with a minimal case. Read the relevant documentation page. Use the diagnostics guide to isolate the layer. ← Previous Next → SUPPORT.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Accessibility Report", "path": "accessibility-report.html", "content": "Accessibility Report Skip to content Accessibility Report Pages without <h1> CONTRIBUTING.html Pages without <title> CONTRIBUTING.html Pages with images without alt attribute All images have alt attributes. ← Previous Next →", "lang": "en", "section": "docs" }, { "title": "Bootstrap Contracts", "path": "bootstrap_contracts.html", "content": "Bootstrap Contracts Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Bootstrap Contracts HTML reading page generated from the source Markdown document. Documentation Source Sitemap Source Markdown Reading mode This page is the static HTML reader for bootstrap_contracts.md . Internal Markdown links are rewritten to HTML when a matching reading page exists. Bootstrap Contracts This page is the index for the bootstrap-native contract surface. Overview Bootstrap contracts are split across artifacts, readable specs, snapshots, and gates so that a contributor can understand both the human intent and the exact machine-checked surface. Contract area Primary reference Seed trust chain docs/bootstrap_seed.md Native IR format docs/bootstrap_native_ir.md Snapshot evidence tests/bootstrap_native/README.md Full local gate make bootstrap-native-contract Fast local gate make bootstrap-native-fast-contract Seed trust chain: docs/bootstrap_seed.md Native IR contract: docs/bootstrap_native_ir.md Bootstrap-native snapshots: tests/bootstrap_native/README.md Local full contract target: make bootstrap-native-contract Local fast contract target: make bootstrap-native-fast-contract CI job: bootstrap-native-contract The bootstrap contract is intentionally split across readable docs, checked seed artifacts, deterministic snapshots, and visible CI steps. A change that affects the seed parser, generated shell backend, command behavior, or canonical compiler entry must carry the matching snapshots in the same change. Responsibilities Keep bootstrap trust boundaries obvious during reviews. Point contributors to the right contract document for each bootstrap layer. Tie source edits to the exact gates that defend them. Invariants Seed, IR, generated shell behavior, and snapshots must move together. A change to the bootstrap surface without updated evidence is considered incomplete. The fast local gate may optimize execution time, but not reduce the contract coverage it claims to represent. Pipeline The bootstrap-native path connects documentation to executable verification: The seed and native IR specs describe the accepted surface. Bootstrap sources and generated artifacts produce deterministic outputs. Snapshot suites pin those outputs. CI and local make targets enforce the contract continuously. Driver Bootstrap is exposed through the driver surface as much as through compiler internals, so driver behavior changes must be considered part of this contract. Data Flow Review starts from the seed and IR docs. Source edits update seed, stage, or emitted shell behavior. Snapshots and contract targets confirm that the visible bootstrap output still matches the documented rules. Examples make bootstrap-native-fast-contract make bootstrap-native-contract tools/bootstrap_native_fixture_matrix.sh These commands are useful in combination: the fast target gives a quick signal, the full contract target verifies the whole native chain, and the fixture matrix shows whether the touched bootstrap form is already covered by a snapshot. PR Checklist Before publishing a bootstrap-native change: Run make bootstrap-native-contract . Run make docs-paths-check . Run make bootstrap-contracts-index-check . Run tools/bootstrap_native_fixture_matrix.sh and confirm the touched surface is covered by snapshots. If toolchain/seed/vittec0.seed changed, confirm toolchain/seed/manifest.txt changed with the new SHA-256. If generated shell behavior changed, confirm the relevant shell.*.must snapshots under tests/bootstrap_native/ changed with it. If parser or diagnostic behavior changed, confirm at least one .ir.must or .err.must snapshot changed with it. ← Previous Next → bootstrap_contracts.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Bootstrap Migration Checklist", "path": "bootstrap_migration_checklist.html", "content": "Bootstrap Migration Checklist Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Bootstrap Migration Checklist HTML reading page generated from the source Markdown document. Documentation Source Sitemap Source Markdown Reading mode This page is the static HTML reader for bootstrap_migration_checklist.md . Internal Markdown links are rewritten to HTML when a matching reading page exists. Bootstrap Migration Checklist The numbered-stage bootstrap has been retired. This checklist records the remaining path from a seed-rooted bootstrap to autonomous self-hosting. Overview Bootstrap trust, compiler generation, and official self-host completion are separate contracts. The seed path is complete; autonomous compiler generation is still in transition. Responsibilities Keep the seed manifest and executable synchronized. Reject fallback compilers and retired bootstrap paths. Report self-hosting gaps instead of treating transition output as complete. Invariants Only the manifest-pinned seed may initialize bootstrap execution. All bootstrap gates are blocking and deterministic. Full self-hosting requires parity and removal of every transition bridge. Data Flow vittec0.seed installs bin/vittec0 , which validates and builds the canonical compiler entry. Generated compilers rebuild that same entry only inside the self-host completion audit. Completed Checked: Pin toolchain/seed/vittec0.seed with a manifest and reviewed source. Checked: Declare a single seed item in toolchain/bootstrap-config.json . Checked: Remove numbered stage sources and bootstrap scripts. Checked: Remove active build, test, CI, release, install, and package references to numbered stages. Checked: Make missing or invalid seed state fatal with no compiler fallback. Checked: Run bootstrap CI gates as blocking jobs. Checked: Verify deterministic seed installation, IR, and native fixture emission. Checked: Keep the repository host-source audit free of bootstrap exceptions. Remaining Open: Remove the transition bridge from generated compiler payloads. Open: Obtain byte-identical successive compiler generations. Open: Compile the full compiler, runtime, and standard library with the generated compiler without delegating to the seed or a host compiler. Open: Validate every supported object, archive, executable, and cross-target format through dedicated platform gates. Open: Make python3 tools/selfhost_completion_audit.py --strict-complete pass. Required Evidence make seed-verify make bootstrap-source-of-truth make bootstrap-vitte-hard-gate make bootstrap-verify toolchain/test_bootstrap_reproducibility.sh python3 tools/selfhost_completion_audit.py --strict-complete The first four commands prove the current seed-rooted bootstrap contract. Only the strict self-host completion audit can close the final migration item. ← Previous Next → bootstrap_migration_checklist.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Vitte Bootstrap Native + Diagnostics Changelog", "path": "bootstrap_native_diagnostics_changelog.html", "content": "Vitte Bootstrap Native + Diagnostics Changelog :root { --ink: #17211d; --muted: #5e6b64; --paper: #f5f1e8; --panel: #fffaf0; --line: #d8cbb6; --accent: #0f6b5f; --accent-2: #b35f19; --code: #24342e; } * { box-sizing: border-box; } body { margin: 0; color: var(--ink); background: radial-gradient(circle at top left, rgba(15, 107, 95, 0.18), transparent 34rem), linear-gradient(135deg, #efe5d1 0%, var(--paper) 50%, #e7d9c0 100%); font-family: Georgia, \"Times New Roman\", serif; line-height: 1.58; } main { width: min(1120px, calc(100% - 32px)); margin: 0 auto; padding: 48px 0 64px; } header { border: 1px solid var(--line); background: rgba(255, 250, 240, 0.9); box-shadow: 0 18px 50px rgba(41, 31, 19, 0.12); padding: 34px; margin-bottom: 26px; } h1, h2, h3 { line-height: 1.1; margin: 0; } h1 { font-size: clamp(2.4rem, 5vw, 5.3rem); letter-spacing: -0.055em; max-width: 920px; } h2 { font-size: clamp(1.6rem, 3vw, 2.4rem); margin-bottom: 14px; } h3 { color: var(--accent); font-size: 1.1rem; margin-bottom: 8px; text-transform: uppercase; letter-spacing: 0.08em; } .meta { display: flex; flex-wrap: wrap; gap: 10px; margin-top: 24px; } .pill { border: 1px solid var(--line); background: #fff5df; color: var(--muted); padding: 7px 11px; font-size: 0.93rem; border-radius: 999px; } .grid { display: grid; grid-template-columns: 1fr 1fr; gap: 18px; } section, .card { border: 1px solid var(--line); background: rgba(255, 250, 240, 0.92); padding: 24px; } section { margin-top: 18px; } ul { margin: 10px 0 0; padding-left: 20px; } li + li { margin-top: 7px; } code { color: var(--code); background: #eadcc3; border: 1px solid #d7c4a7; padding: 1px 5px; border-radius: 4px; font-family: \"SFMono-Regular\", Consolas, \"Liberation Mono\", monospace; font-size: 0.92em; } pre { overflow: auto; margin: 12px 0 0; padding: 16px; color: #f8f2e8; background: #18241f; border-left: 5px solid var(--accent-2); font-family: \"SFMono-Regular\", Consolas, \"Liberation Mono\", monospace; font-size: 0.92rem; } pre code { color: inherit; background: transparent; border: 0; padding: 0; } .summary { font-size: 1.18rem; color: var(--muted); max-width: 900px; margin: 20px 0 0; } .status { display: grid; grid-template-columns: repeat(3, 1fr); gap: 12px; margin-top: 18px; } .status strong { display: block; color: var(--accent); font-size: 1.4rem; } .footer-note { color: var(--muted); margin-top: 18px; font-size: 0.95rem; } @media (max-width: 760px) { main { width: min(100% - 20px, 1120px); padding-top: 20px; } header, section, .card { padding: 18px; } .grid, .status { grid-template-columns: 1fr; } } Bootstrap native + diagnostics changelog Synthese complete du patch: extension du build natif bootstrap, diagnostics directs branches sur FTL, exemples utilisateur, snapshots et verification. Date: 2026-06-23 Commande officielle: vitte build main.vit -o main Langues FTL: en , fr Statut: gates passes 20 exemples utilisateur ajoutes et compiles. 25 cles E_BOOTSTRAP_* ajoutees par locale en/fr . 7 gates executes avec succes. Bootstrap Native Support ajoute extract_native_main_return() reconnait maintenant les records simples. Support des champs comme p.x et p.y . Support des sommes de champs, litteraux, constantes et appels pseudo-stdlib deja reconnus. Support de records types: let p: Point = Point { ... } . Fixture native tests/bootstrap_native/record_field_sum.vit avec exit code attendu 30 . Commande build La commande valide reste strictement vitte build main.vit -o main . Le raccourci non souhaite vitte build main n'est pas active. Test manuel confirme: sans .vit echoue, avec .vit reussit. Diagnostics FTL cli_error() passe par localized_diagnostic_message() et localized_diagnostic_hint() . diag() dans le parseur AWK bootstrap utilise les messages FTL pour les erreurs E_BOOTSTRAP_* . --lang fr fonctionne sur les diagnostics directs bootstrap de dump-native-ir , check et build . Resolution robuste du repertoire locales/ depuis le repo, le seed, ou un payload natif temporaire. Le shell natif genere initialise diagnostics_lang=\"${VITTE_LANG:-en}\" . Locales Les fichiers locales/en/diagnostics.ftl et locales/fr/diagnostics.ftl ont recu les cles bootstrap suivantes. legacy bootstrap subset diagnostic legacy bootstrap subset diagnostic hint E_BOOTSTRAP_FULL_COMPILER_BRIDGE_DISABLED E_BOOTSTRAP_UNKNOWN_STRING_CONST E_BOOTSTRAP_UNKNOWN_INT_CONST E_BOOTSTRAP_EXPECTED_STRING_CONST E_BOOTSTRAP_EXPECTED_INT_CONST E_BOOTSTRAP_UNKNOWN_PROC_PREFIX E_BOOTSTRAP_DUP_PROC_PREFIX E_BOOTSTRAP_CONST_SIGNATURE E_BOOTSTRAP_MAIN_SIGNATURE E_BOOTSTRAP_PROC_SIGNATURE_PARAMS E_BOOTSTRAP_PROC_SIGNATURE_RETURN E_BOOTSTRAP_PROC_SIGNATURE E_BOOTSTRAP_PROC_BODY E_BOOTSTRAP_PROC_BODY_GIVE E_BOOTSTRAP_MAIN_BODY E_BOOTSTRAP_PROC_BODY_INT E_BOOTSTRAP_PROC_BODY_STRING E_BOOTSTRAP_TOP_LEVEL E_BOOTSTRAP_UNCLOSED_PROC E_BOOTSTRAP_EXPORT E_BOOTSTRAP_SPACE E_BOOTSTRAP_VERSION E_BOOTSTRAP_BANNER Snapshots Et Fixtures Ajout de tests/bootstrap_native/bad_unknown_const.fr.err.must . Ajout de tests/bootstrap_native/cli.bui", "lang": "en", "section": "docs" }, { "title": "Bootstrap Native IR v1", "path": "bootstrap_native_ir.html", "content": "Bootstrap Native IR v1 Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Bootstrap Native IR v1 HTML reading page generated from the source Markdown document. Documentation Source Sitemap Source Markdown Reading mode This page is the static HTML reader for bootstrap_native_ir.md . Internal Markdown links are rewritten to HTML when a matching reading page exists. Bootstrap Native IR v1 native_ir_v1 is the textual intermediate representation used by the bootstrap-native seed compiler for the early build-native path. It is small by design: the format describes only the compiler identity strings, optional named string constants, and the native process exit code needed by seed-generated fixtures and compiler payloads. The canonical implementation is toolchain/seed/vittec0.seed . Golden coverage lives in tests/bootstrap_native . native_ir_v1 is the stable bootstrap contract. The shell emitted by build-native is the current POSIX bootstrap backend, not the IR contract itself. The backend may be replaced later as long as native_ir_v1 snapshots and documented command behavior remain stable. Versioning native_ir_v1 is additive-only. New records or accepted source forms may be added when older v1 readers can ignore or reject them safely under the existing fail-closed rules. Any breaking format change must use a new first-line tag, starting with native_ir_v2 . Breaking changes include changing the meaning of an existing record, removing a required record, changing record order requirements, or changing diagnostics in a way that v1 snapshots can no longer defend. native_ir_v1 snapshots remain authoritative as long as seed artifacts read or emit v1. Introducing a future v2 must keep v1 snapshots and drift checks until the stage0 trust root no longer depends on v1. Format The IR is UTF-8 text with LF line endings. The first line is the version tag: native_ir_v1 Remaining lines are key/value records: const.string.<NAME>=<string value> const.int.<NAME>=<integer> proc.int.<name>=<integer> version_text=<string value> banner_text=<string value> main.return=<integer> Rules: const.string.&lt;NAME&gt; records are optional and appear in source declaration order. const.int.&lt;NAME&gt; records are optional and appear in source declaration order with string constants. proc.int.&lt;name&gt; records are optional and appear in source declaration order. In v1 they are record-only: generated shell compilers do not expose these procedures as callable commands yet. NAME is an uppercase bootstrap constant identifier: [A-Z_][A-Z0-9_]* . version_text , banner_text , and main.return appear exactly once. String values are the decoded contents of bootstrap string literals. The v1 subset does not support escapes or embedded double quotes. Integer values are signed decimal integers. main.return is a signed decimal integer. If no supported main procedure is present, it defaults to 0 . Example: native_ir_v1 const.string.VERSION_TEXT=vittec native fixture 0.1.0 const.string.BANNER_TEXT=vittec native fixture const.int.EXIT_CODE=0 version_text=vittec native fixture 0.1.0 banner_text=vittec native fixture main.return=0 Source Subset native_ir_v1 is emitted only for the bootstrap-native subset: space &lt;path&gt; const NAME: string = &quot;...&quot; const NAME: int = 123 proc name() -&gt; string { give &quot;...&quot; } proc name() -&gt; string { give NAME } proc name() -&gt; int { give 123 } proc name() -&gt; int { give NAME } proc main(args: list[string]) -&gt; int { give &lt;integer&gt; } proc main(args: list[string]) -&gt; int { give NAME } use &lt;path&gt; / share &lt;path&gt; / import &lt;path&gt; at top level when const BOOTSTRAP_FULL_COMPILER: int = 1 is present proc main(args: list[string]) -&gt; int { ... } with local let , direct call expressions, and if control flow when BOOTSTRAP_FULL_COMPILER: int = 1 is present export * Only version_text() and banner_text() are currently materialized as compiler identity procedures. Other string procedures are rejected until the native bootstrap surface grows intentionally. Integer procedures are accepted and emitted as proc.int.* records to pin the lowering shape, but they are record-only in v1. They are not callable from the generated shell compiler and do not affect process behavior unless their value is used through main.return . When BOOTSTRAP_FULL_COMPILER is enabled, the richer main body is accepted as source coverage for the real compiler entry point, but v1 still lowers it to the same shell contract and keeps main.return=0 . Non-Goals v1 The v1 subset intentionally does not support: string escapes or embedded double quotes, multi-line declarations or multi-line procedure signatures, bool , list, map, user-defined, or composit", "lang": "en", "section": "docs" }, { "title": "Bootstrap Seed Contract", "path": "bootstrap_seed.html", "content": "Bootstrap Seed Contract Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Bootstrap Seed Contract HTML reading page generated from the source Markdown document. Documentation Source Sitemap Source Markdown Reading mode This page is the static HTML reader for bootstrap_seed.md . Internal Markdown links are rewritten to HTML when a matching reading page exists. Bootstrap Seed Contract The bootstrap seed is the trusted stage0 entry point for rebuilding the Vitte toolchain without repo-hosted host-language sources. Files Canonical readable source: toolchain/seed/src/main.vit Audited executable artifact: toolchain/seed/vittec0.seed Pinning manifest: toolchain/seed/manifest.txt toolchain/seed/manifest.txt records the seed source path, artifact path, artifact SHA-256, and expected --version output. make seed-verify checks the manifest hash against the artifact and validates the version string. The readable source is the canonical intent for review. The executable artifact is the stage0 trust root actually run by bootstrap scripts. make seed-verify keeps the two tied at the identity boundary by checking that source VERSION_TEXT , manifest version=... , and vittec0.seed --version match. Change Rule Any intentional seed rotation must update these contracts together: toolchain/seed/src/main.vit when the readable seed behavior changes. toolchain/seed/vittec0.seed when the executable seed artifact changes. toolchain/seed/manifest.txt when the artifact bytes or version change. tests/bootstrap_native/* snapshots when generated native output changes. CI must pass, including make seed-verify and make bootstrap-native-snapshots . The seed artifact must not change on its own. A change to toolchain/seed/vittec0.seed without a matching toolchain/seed/manifest.txt change is treated as seed drift and fails make seed-contract-check . Rotation Checklist Modify toolchain/seed/src/main.vit . Regenerate or edit toolchain/seed/vittec0.seed . Run make seed-rotation-report to inspect the current artifact hash and version. Run make seed-manifest-update to rewrite toolchain/seed/manifest.txt from the audited artifact and source VERSION_TEXT . Run make bootstrap-native-snapshots . Run make bootstrap-verify . Run make seed-contract-check . Local Checks make seed-verify make seed-rotation-report make posix-seed-shell-check make bootstrap-native-snapshots make seed-contract-check make bootstrap-native-drift-check make bootstrap-posix-smoke make build also runs bootstrap integration gates before the final source audit: compiler-real-native-gate compiler-test-suite-check-gate compiler-test-suite-bridge-gate driver-native-json-surface-gate These are complementary to make bootstrap-native-snapshots . The snapshot suite locks seed output and diagnostics; the integration gates verify that the current driver still exposes the expected native JSON envelopes, that the compiler entry builds without a bridge sidecar, and that the compiler test suite bridge remains scoped to compiler test sources. Local Parallelism CI jobs run in isolated workspaces, so their bootstrap artifacts do not collide. In one local worktree, bootstrap targets that install the seed are not parallel-safe because they rewrite shared bin/vittec0 . The single-workspace runner rule is: make bootstrap-native-snapshots installs the seed and mutates bin/vittec0 . make bootstrap-verify reinstalls and verifies bin/vittec0 . make bootstrap-posix-smoke depends on bootstrap-all , so it also rebuilds the seed artifact before running POSIX checks. make bootstrap-native-contract composes those flows and should be treated as an exclusive bootstrap runner in a local worktree. tools/bootstrap_native_snapshots.sh and tools/bootstrap_posix_smoke.sh use per-run temporary directories under target/ and clean them on exit, but the shared bin/vittec* artifacts are intentionally not isolated. Avoid running bootstrap targets concurrently in the same worktree. Source Coverage The readable seed and real compiler entry should exercise the current bootstrap-native forms they rely on: toolchain/seed/src/main.vit must include named string constants, named int constants, proc main(args: list[string]) -&gt; int , and a named constant return. src/vitte/compiler/main.vit must include named VERSION_TEXT and BANNER_TEXT string constants, use a named string constant in version_text() , and define main . This is checked by make bootstrap-source-coverage-check and is included in the bootstrap-native contract targets. The stricter trust-root syntax contract is documented in docs/compiler/selfhost_core_subset.md and enforced by make selfhost-subset-check . Project Path Resolution Bootstrap and driver flows now accept a project directory as the CLI input path. When a command such as ./bin/vitte check . or ./bin/vitte build . -o target/app receives a directory-like path, it resolves the entry in this order: sr", "lang": "en", "section": "docs" }, { "title": "Broken Links", "path": "broken-links.html", "content": "Broken Links Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Broken Links Page Broken Link grammar/diff.html #difflib_chg_to0__0 grammar/grammar_inventory.html index.html#backend_format grammar/grammar_inventory.html index.html#backend_item grammar/grammar_inventory.html index.html#backend_items grammar/grammar_inventory.html index.html#backend_output grammar/grammar_inventory.html index.html#cache_item grammar/grammar_inventory.html index.html#compiler_artifact_decl grammar/grammar_inventory.html index.html#compiler_cache_decl grammar/grammar_inventory.html index.html#compiler_item grammar/grammar_inventory.html index.html#compiler_items grammar/grammar_inventory.html index.html#compiler_phase_decl grammar/grammar_inventory.html index.html#compiler_pipeline_decl grammar/grammar_inventory.html index.html#compiler_stage_decl grammar/grammar_inventory.html index.html#compiler_target_decl grammar/grammar_inventory.html index.html#comptime_decl grammar/grammar_inventory.html index.html#diagnostic_code grammar/grammar_inventory.html index.html#diagnostic_item grammar/grammar_inventory.html index.html#diagnostic_items grammar/grammar_inventory.html index.html#diagnostic_level grammar/grammar_inventory.html index.html#global_decl grammar/grammar_inventory.html index.html#pass_item grammar/grammar_inventory.html index.html#pass_items grammar/grammar_inventory.html index.html#pipeline_step grammar/grammar_inventory.html index.html#target_item grammar/search.html index.html#backend_format grammar/search.html index.html#backend_item grammar/search.html index.html#backend_items grammar/search.html index.html#backend_output grammar/search.html index.html#cache_item grammar/search.html index.html#compiler_artifact_decl grammar/search.html index.html#compiler_cache_decl grammar/search.html index.html#compiler_item grammar/search.html index.html#compiler_items grammar/search.html index.html#compiler_phase_decl grammar/search.html index.html#compiler_pipeline_decl grammar/search.html index.html#compiler_stage_decl grammar/search.html index.html#compiler_target_decl grammar/search.html index.html#comptime_decl grammar/search.html index.html#diagnostic_code grammar/search.html index.html#diagnostic_item grammar/search.html index.html#diagnostic_items grammar/search.html index.html#diagnostic_level grammar/search.html index.html#global_decl grammar/search.html index.html#pass_item grammar/search.html index.html#pass_items grammar/search.html index.html#pipeline_step grammar/search.html index.html#target_item ← Previous Next → broken-links.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Docs Changelog", "path": "changelog.html", "content": "Docs Changelog Skip to content Docs Changelog 94b0f0e01 2026-07-18 Refresh remaining bootstrap documentation b1ec09b80 2026-07-18 Regenerate seed-rooted documentation site fd47f8206 2026-07-18 Remove retired bootstrap stage snapshots 22e2d8ba8 2026-07-18 Retire numbered bootstrap documentation f9bffb8f2 2026-07-18 delete 7103e8521 2026-07-18 Replace retired stage parity gate 6ef4474ad 2026-07-18 Document seed-rooted bootstrap architecture eb99e1029 2026-07-13 typeck: formalize production typing rules be4e0f00e 2026-07-13 backend: compare C and LLVM corpus semantics 99f18f806 2026-07-13 backend: add explicit cross sysroots 4933a1e23 2026-07-13 backend: verify x86_64 and aarch64 objects e623b95ad 2026-07-13 backend: encapsulate native toolchain commands ee4c3eeaf 2026-07-13 backend: add native debug and unwind metadata b7b030fa1 2026-07-12 backend: verify native object structure 397d1bba7 2026-07-12 backend: emit deterministic native objects f421ae8a6 2026-07-12 backend: model target layouts and calling conventions 20e6709ca 2026-07-12 add db02fed05 2026-06-30 docs: add auto-refresh and anti-cache policy 4d54cca2c 2026-06-30 extend compiler in progress 18ac38065 2026-06-29 fix 4269fb3eb 2026-06-29 @Kapra-foster 12ef79453 2026-06-26 Harden bootstrap native gates and update changelogs 8a3c9a91c 2026-06-25 Align compiler reachability audit with real entry 0a10ad3e2 2026-06-25 Freeze self-host trust-root subset contract 4e0119b76 2026-06-23 cli: add --format json for vitte check; document in changelogs ed0903b38 2026-06-23 Update CONTRIBUTING.html e03949642 2026-06-23 bootstrap: expand native diagnostics coverage c8c7e1856 2026-06-22 doc extend chapters + fix Header 2f5a38078 2026-06-22 docs: stabilize shell and validate frontend output b946a2e91 2026-06-21 add 5ab5038b9 2026-06-21 fix c04cfe9eb 2026-06-21 add 38964fa93 2026-06-21 fix global header error bc7f60225 2026-06-21 fix header now --static 41ac01da6 2026-06-21 Align docs with Vitte project surface 17b2c72c2 2026-06-21 Fix docs header stability 5481126fb 2026-06-18 Stabilize grammar sync headers a3a3ca5e0 2026-06-18 Fix ci-fast snapshot drift 580ed77b0 2026-06-17 Vitte compiler pipeline and expands executable native coverage. d0bfb599f 2026-06-15 config fix 122839e13 2026-06-13 Add localized Fluent diagnostics 55652c3d2 2026-06-12 Refresh docs and bootstrap snapshots 611929b1a 2026-06-12 Make compiler checks portable 2fa34f52d 2026-06-12 Add diagnostic locale coverage checks 6c34a8956 2026-06-10 @ e21f9c266 2026-06-07 Expand stdlib reference module documentation 21d52ae24 2026-06-06 [docs][stdlib] expand complete stdlib reference and Wikipedia-style documentation framework 1e74af966 2026-06-06 Replace missing Playwright docs job with Python checks 856f78d49 2026-06-06 Fix docs local smoke gate 5574c0d3c 2026-06-06 Refresh generated docs outputs a00dc29d0 2026-06-06 Fix docs static extras and broken links a71066e58 2026-06-06 fix banner align search 3f5f8fe1b 2026-06-06 @Kapra-foster @roussov 5525aade5 2026-06-05 Add bootstrap native gates and project-path driver surfaces 1a627c38c 2026-06-04 add 75b03f70f 2026-06-02 docs: Add C code equivalents to book examples 54d7531ac 2026-06-02 add 757ae87cd 2026-05-25 @ 2ab0a3302 2026-05-24 add a13b35117 2026-05-24 @Kapra-foster 4a6ab80e6 2026-05-23 feat(compiler): add metrics/health, diagnostics+recovery, lsp stability, incremental invalidation 3d04521ba 2026-05-23 @Kapra-foster 94bb8a986 2026-05-22 compiler: harden pipeline, add native panic boundary, expand targets and add directory READMEs 981db61d7 2026-05-21 add aed5a409b 2026-05-21 selfhost: force vitte.compiler.surface and stabilize strict gate 41d0650cf 2026-05-18 Clarify ownership-aware grammar semantics for assignments, places, and references efd8ca542 2026-05-18 @Kapra-foster 7dddcc296 2026-05-18 Merge pull request #85 from vitte-lang/bootstrap-runtime-monotonic-timestamps 5eadfd1aa 2026-05-18 add 8e1fe4dbf 2026-05-18 delete 5ac5357e6 2026-05-18 Add HTML readers for source-backed docs 756d592f5 2026-05-18 Add structured lexer and AST-driven analysis paths 99a8a5bb5 2026-05-18 Rebuild compiler structure and expand project updates 881e8bedb 2026-05-16 Add comprehensive compiler architecture docs ec6d5d8f4 2026-05-15 add 514f8457a 2026-05-14 update 55533b264 2026-05-14 add 62f52ba96 2026-05-14 docs(site): remove SRI on local assets to restore CSS rendering 4e308557c 2026-05-14 @docs/vitte-lang_update 28e857264 2026-05-14 Merge pull request #73 from Kapra-foster/main ← Previous Next →", "lang": "en", "section": "docs" }, { "title": "Vitte Community", "path": "community.html", "content": "Vitte Community Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Vitte Community Questions, patches, technical signals, and quick feedback on the project. Welcome Documentation Visual Preview Sitemap Download Source Community News Diagnostics Suggestions @goginx community note: Vitte community work is organized around measurable compiler progress: every visible claim should point to a gate, a regression test, a diagnostic snapshot, or a generated report. Contributors are encouraged to discuss features in terms of contracts that can fail in CI, especially around frontend coverage, ownership, compile-time simulation, backend artifacts, and documentation accuracy. This keeps feedback practical: a proposal should say what behavior is expected, how it is verified, and which user-facing diagnostic or report proves the result. Code of Conduct Be precise, respectful, and technical in review and issue threads. Critique code and assumptions, never people. Attach reproducible evidence when reporting regressions. How to Contribute Open an issue with context, expected behavior, and impact. Propose a minimal patch linked to tests or docs evidence. Run documentation and compiler gates before asking for review. Public Roadmap Documentation priorities (compiler surface + stdlib coverage). Release timeline (patches, milestones, adoption updates). Implementation tracks (driver, grammar, diagnostics, backend). Example community flow # Example contribution path 1. Read the docs on the feature in doc.html 2. Inspect the source in source.html 3. Check diagnostics if you reproduce a failure 4. Share a minimal issue and patch in community This page is a hub for signals, not a replacement for the feature docs or implementation details. Proof-First Snapshot Dernière mise à jour: May 22, 2026 Build ID / Commit: docs-v4 / main (see status.html) Known issues Several long thread notes need compaction into focused contribution guides. Community digest is still mixed between governance notes and technical deep dives. Compatibility matrix Audience Status Entry point New contributors Ready Contributing guide Maintainers Ready Source architecture Beta users Ready Release and feedback updates Useful messages Thread Summary Links @goginx compiler health update (May 23, 2026) Community contributors can now inspect compiler health with metrics + dashboard outputs and validate incremental/LSP/recovery behavior through dedicated stability contracts. News · Documentation · Source Compiler delivery gates (40→120) Community can now validate end-to-end proof artifacts for self-host, release packaging, workspace checks, deterministic outputs, and strict compiler gate reports. News · Source · Documentation Start with the right thread Help for crashes, contribution for patches, diagnostics for errors, source for architecture. Diagnostics · Source Overall progress of the project The book now lives under docs/book , and the documentation is linked more directly to the essential chapters. Documentation · Release 0.1.0 Stdlib extended Overview of families core , kernel , collections , compression , crypto , datetime , encoding , io , json , math , path , regex , strings , And sysinfo . Stdlib · Contract · Source The CLI, explained simply vitte explain to understand a diagnosis, vitte check to validate a piece of code. Diagnostics · Download · Documentation Quick sort News : announcements and releases. Community : help, contributions, docs. Support : diagnostics and assistance. Dev : source and patches. Thread rules One post, one topic. A minimal example is better than a long, fuzzy block. When it is an error, start with vitte explain . @owner @owner is the project owner for release governance and technical arbitration. Owner scope Final decision on release readiness and milestone closure. Validation of evidence-backed checklist updates (no unchecked claims). Arbitration when architecture, ABI, or stdlib contracts conflict. Approval of breaking changes impacting compiler/stdlib public surface. How to escalate to @owner Use a concise issue summary: context, risk, proposed action, expected impact. Attach concrete artifacts (logs, reports, matrix links, reproduction path). Mark severity explicitly: critical , major , or minor . Owner-first contribution contract No checklist item is marked complete without repository evidence. Automation gates are preferred over manual status updates. Runtime and ABI claims must be backed by target-specific fixtures/reports. @roussov on the latest compiler modifications @roussov wrote this long-form community note to explain the latest compiler modifications in plain architectural terms. If you only want the short release summary, see News . If you want the full implementation story, this note is the right place to start. The most important change is not a new command, not a visual refresh, and not a larger file coun", "lang": "en", "section": "docs" }, { "title": "Dashboard", "path": "dashboard.html", "content": "Dashboard Skip to content Dashboard Documentation Status Status (JSON) Status Public Site Statistics Site Statistics Accessibility Accessibility Report SEO SEO Report Search Indexes Docs Index Grammar Index Book Index All Index Changelog Changelog Other Docs Tree Broken Links ← Previous Next →", "lang": "en", "section": "docs" }, { "title": "Vitte Diagnostics", "path": "diagnostics.html", "content": "Vitte Diagnostics Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Vitte Diagnostics Quick consultation of diagnostics: a code, a layer, a correction. Welcome Documentation Visual Preview Sitemap Download Source Community News Diagnostics Suggestions Source of truth The active diagnostics surface is the Vitte compiler itself. For implementation details, start from src/vitte/compiler/diagnostics/diagnostic.vit and the technical note docs/compiler/diagnostics.md . The bootstrap seed diagnostics described in docs/seed_diagnostics.md are a narrower stage0 contract, not the full compiler surface. Official sequence vitte check <file> vitte check <file> --diagnostics-json vitte run <file> vitte parse <file> vitte explain <code> vitte dump-ast <file> vitte dump-hir <file> vitte dump-mir <file> Use tests/strict_ok.vit as the tracked smoke fixture when a docs page needs a small known-good source file. Stable JSON surface schema = \"vitte.compiler.surface\" surface = \"diagnostics\" valid tells whether the request succeeded pipeline_failed_at identifies the first failing stage primary_report.diagnostics[] contains the flattened report phase_reports.* keeps per-phase diagnostics Phase map frontend : lexer , parser , ast_validation resolution : module_resolution , symbol_resolution , sema middle-end : hir , typeck , borrowck , mir , mir_lowering , mir_verification , ir backend : backend , linker , runtime_execution driver : CLI/input/configuration failures before or around the pipeline Frequent codes PARSE_E_UNCLOSED_BLOCK - parser reached EOF before a closing delimiter E1005 - unknown identifier TYPECK_E_ASSIGN_MISMATCH - assignment type mismatch BORROWCK_E_USE_AFTER_MOVE - moved value used later LIMIT_FILE_SIZE_MAX - source exceeds hard input-size policy What to do first Read the first failing phase and code, not the whole waterfall. Reduce the repro to the smallest file that still fails. Re-run with --diagnostics-json when you need machine-readable detail. Use AST/HIR/MIR JSON dumps only after the frontend phase is clean enough to progress. Quick index parse : malformed syntax, recovery diagnostics, unclosed delimiters. resolve : missing modules, symbols, visibility and name binding issues. typeck : incompatible assignments, call arity/type mismatches, non-exhaustive matches. borrowck : use-after-move, borrow conflicts, lifetime failures. driver : invalid CLI input, path/policy issues, hardening limits. Example space sample proc main() -> void { let x = 1 give x + \"bad\" } This minimal example is useful for understanding diagnostics: the compiler can parse the code, but it will fail later with a type mismatch because int + string is invalid. Reduce the repro to this smallest form when you triage a failure. Practical reading Diagnostics should be read as a contract, not as a wall of text. The phase tells you where the pipeline stopped, the code names the stable failure class, and the JSON envelope lets you inspect the same event without scraping text output. For a fast triage, use this order: Identify pipeline_failed_at or the first human-visible phase. Read the primary code, message, label, note, and help. Reduce the repro to the smallest snippet that still fails. Re-run with --diagnostics-json if you need exact fields or per-phase separation. Only then move to AST/HIR/MIR dumps if the failing phase is past parsing. That sequence keeps bug reports useful: the report should name the phase, the code, the smallest repro, and the expected behavior instead of only describing the symptom. If you need a broader starting point, read Documentation for the compiler surface and Source for the implementation path. ← Previous Next → diagnostics.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Vitte Documentation", "path": "doc.html", "content": "Vitte Documentation Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Sommaire de la documentation Index HTML complet du dossier docs/ . Cette page relie les 325 fichiers HTML disponibles. Acces rapide Les pages sont regroupees par dossier pour rendre le sommaire lisible malgre le volume. Racine docs (34 page(s)) beta_program (3 page(s)) beta_program/bug_fixing_iteration (4 page(s)) beta_program/feedback_collection (3 page(s)) book (23 page(s)) book/chapters (90 page(s)) book/chapters/keywords (52 page(s)) book/grammar (9 page(s)) book/grammar/railroad (2 page(s)) book/logique (6 page(s)) book/poche (14 page(s)) book/poche/chapters (78 page(s)) grammar (6 page(s)) profiling (1 page(s)) Liens utiles Accueil Visual Preview Sitemap Recherche Resume du livre Index grammaire Statut docs Racine docs 34 page(s) 404.html BOOTSTRAP_NATIVE_MIGRATION_FROM_RUST.html BOOTSTRAP_VITTE_FILE_MAPPING.html COMPILER_DRIVER_MIGRATION.html CONTRIBUTING.html MAKE_TARGETS.html MD_MIGRATION.html MODULE_REFERENCE.html PACKAGE_INDEX.html PACKAGE_MATURITY.html SUPPORT.html bootstrap_contracts.html bootstrap_migration_checklist.html bootstrap_native_ir.html bootstrap_seed.html changelog.html community.html diagnostics.html doc.html docs-architecture.html download.html index.html news.html offline.html search.html seed_diagnostics.html sitemap.html source-guides.html source.html start-here.html status-public.html status.html suggestions.html vitte-ebnf-memory.html beta_program 3 page(s) beta_program/CANDIDATE_SOURCING.html beta_program/GUIDELINES_AND_NDA.html beta_program/ONBOARDING_PACK.html beta_program/bug_fixing_iteration 4 page(s) beta_program/bug_fixing_iteration/FEATURE_REQUEST_TOP3.html beta_program/bug_fixing_iteration/FIX_PLAN.html beta_program/bug_fixing_iteration/RETEST_REPORT.html beta_program/bug_fixing_iteration/TRIAGE.html beta_program/feedback_collection 3 page(s) beta_program/feedback_collection/MONITORING_AND_METRICS.html beta_program/feedback_collection/TESTER_DEPLOYMENT_PLAN.html beta_program/feedback_collection/WEEKLY_SYNC_TEMPLATE.html book 23 page(s) book/chapters/20a-overall-architecture.html book/chapters/27-grammar.html book/chapters/34-compiler-mental-model.html book/chapters/64-ast-to-ir-mapping.html book/STYLE.html book/checklist.html book/ci.html book/classic-mistakes.html book/cli.html book/compiler-stdlib-contract.html book/errors.html book/glossary.html book/index.html book/roadmap-pedagogique.html book/start-30-min.html book/status.html book/stdlib.html book/chapters/41-versioning-and-migration.html book/chapters/41-versioning-and-migration.html book/roadmap-pedagogique.html book/stdlib.html book/summary.html book/technical-index.html book/chapters 90 page(s) book/chapters/00-avant-propos.html book/chapters/00-foreword.html book/chapters/00-preface.html book/chapters/01-demarrer.html book/chapters/01-starting.html book/chapters/02-philosophie.html book/chapters/02-philosophy.html book/chapters/03-project.html book/chapters/03-projet.html book/chapters/04-syntax.html book/chapters/04-syntaxe.html book/chapters/05-types.html book/chapters/06-procedures.html book/chapters/07-control.html book/chapters/07-controle.html book/chapters/08-structures.html book/chapters/09-modules.html book/chapters/10-diagnostics.html book/chapters/11-collections.html book/chapters/12-pointers.html book/chapters/13-generics.html book/chapters/13-generiques.html book/chapters/14-macros.html book/chapters/15-pipeline.html book/chapters/16-interop.html book/chapters/16a-vitte-binding.html book/chapters/17-stdlib.html book/chapters/18-tests.html book/chapters/19-performance.html book/chapters/20-repro.html book/chapters/20-reproducibility.html book/chapters/20a-architecture-globale.html book/chapters/20a-overall-architecture.html book/chapters/21-cli-project.html book/chapters/22-http-project.html book/chapters/23-system-project.html book/chapters/24-kv-project.html book/chapters/25-arduino-project.html book/chapters/26-editor-project.html book/chapters/27-grammar.html book/chapters/28-conventions.html book/chapters/29-style.html book/chapters/30-faq.html book/chapters/31-build-errors.html book/chapters/32-modules-catalog.html book/chapters/33-suggested-chapters.html book/chapters/34-compiler-mental-model.html book/chapters/35-error-message-anatomy.html book/chapters/36-naming-strategies.html book/chapters/37-large-scale-module-conventions.html book/chapters/38-type-driven-refactoring.html book/chapters/39-stable-public-api-design.html book/chapters/40-breaking-compatibility.html book/chapters/41-versioning-and-migration.html book/chapters/42-robust-procedure-patterns.html book/chapters/43-vitte-code-anti-patterns.html book/chapters/44-measure-before-optimizing.html book/chapters/45-performance-allocations-copies.html book/chapters/46-adapted-data-structures.html book/chapters/47-reproducible-debugging.html book/chapt", "lang": "en", "section": "docs" }, { "title": "Docs Architecture", "path": "docs-architecture.html", "content": "Docs Architecture Skip to content Docs Architecture Single source pipeline for static docs, grammar artefacts, and SEO/security outputs. Pipeline (exact) tools/build_docs_site.py tools/build_grammar_extras.py tools/sync_ebnf_memory_pages.py tools/build_static_extras.py Sources docs/*.html (EN root editable pages) src/vitte/grammar/vitte.ebnf (source of truth) docs/css/* , docs/js/* Example Edit the HTML page directly in docs/ to update the site. The build pipeline then injects canonical metadata, refreshes the SEO metadata, and updates the search index automatically. Generated outputs docs/search-index*.json docs/sitemap.xml , docs/robots.txt docs/build-manifest.json , docs/status.json docs/grammar/rules*.json , docs/grammar/grammar.sha256 Assets policy Local docs assets ( docs/css/* , docs/js/* ) must not carry integrity= or crossorigin= attributes. Enforced by tools/docs/check_assets_policy.py and CI docs-quality . Automatic cleanup tool: tools/docs/refresh_assets_policy.py . Refresh and cache policy Development auto-refresh is built into docs/js/main.js . Enable it by opening any page with ?dev-refresh=1&refresh=5 to reload every 5 seconds. While dev auto-refresh is enabled, the docs service worker is unregistered to avoid stale local cache during editing. Production cache headers for static hosting live in docs/_headers : HTML, CSS, JS, search indexes, and SVGs are all forced to revalidate so the site does not stay pinned to stale browser cache. docs/_headers is honored by hosts such as Netlify, Cloudflare Pages, and many custom static servers; GitHub Pages may ignore it, so query-versioned assets still matter there. Editable vs generated Editable Generated docs/*.html , docs/css/* , docs/js/* , src/vitte/grammar/vitte.ebnf search-index*.json , sitemap.xml , build-manifest.json , checksums.txt , *.sha256 Ownership map Artifact Updater Header/footer/nav + core search index tools/build_docs_site.py Grammar toolbox/diff/status/rules API tools/build_grammar_extras.py EBNF memory pages + checksum tools/sync_ebnf_memory_pages.py SEO/CSP/checksums/health/static extras + asset policy cleanup tools/build_static_extras.py Doctor checks and fix suggestions tools/docs_doctor.py No-SRI policy gate for local assets tools/docs/check_assets_policy.py ← Previous Next →", "lang": "en", "section": "docs" }, { "title": "Docs Tree", "path": "docs-tree.html", "content": "Docs Tree Skip to content Docs Tree Path Type Size (bytes) 404.html .html 3496 BOOTSTRAP_NATIVE_MIGRATION_FROM_RUST.html .html 7820 BOOTSTRAP_VITTE_FILE_MAPPING.html .html 9388 COMPILER_DRIVER_MIGRATION.html .html 11993 CONTRIBUTING.html .html 2965 MAKE_TARGETS.html .html 11232 MD_MIGRATION.html .html 5627 MODULE_REFERENCE.html .html 7877 PACKAGE_INDEX.html .html 5491 PACKAGE_MATURITY.html .html 5156 RELEASE_NOTES_TEMPLATE.html .html 7159 SUPPORT.html .html 5279 accessibility-report.html .html 2154 assets.json .json 3042 audits/memory_safety.html .html 16305 beta_program/CANDIDATE_SOURCING.html .html 4574 beta_program/GUIDELINES_AND_NDA.html .html 4783 beta_program/ONBOARDING_PACK.html .html 4339 beta_program/bug_fixing_iteration/FEATURE_REQUEST_TOP3.html .html 4155 beta_program/bug_fixing_iteration/FIX_PLAN.html .html 4843 beta_program/bug_fixing_iteration/RETEST_REPORT.html .html 4404 beta_program/bug_fixing_iteration/TRIAGE.html .html 4796 beta_program/feedback_collection/MONITORING_AND_METRICS.html .html 4916 beta_program/feedback_collection/TESTER_DEPLOYMENT_PLAN.html .html 4754 beta_program/feedback_collection/WEEKLY_SYNC_TEMPLATE.html .html 4718 book/STYLE.html .html 6449 book/book-health.html .html 984 book/book-health.json .json 3 book/chapters/00-avant-propos.html .html 32735 book/chapters/00-foreword.html .html 33087 book/chapters/00-preface.html .html 33030 book/chapters/01-demarrer.html .html 30249 book/chapters/01-starting.html .html 30063 book/chapters/02-philosophie.html .html 33276 book/chapters/02-philosophy.html .html 33125 book/chapters/03-project.html .html 30056 book/chapters/03-projet.html .html 30231 book/chapters/04-syntax.html .html 29489 book/chapters/04-syntaxe.html .html 29588 book/chapters/05-types.html .html 30790 book/chapters/06-procedures.html .html 29583 book/chapters/07-control.html .html 30007 book/chapters/07-controle.html .html 30109 book/chapters/08-structures.html .html 30856 book/chapters/09-modules.html .html 30321 book/chapters/10-diagnostics.html .html 29790 book/chapters/11-collections.html .html 31484 book/chapters/12-pointers.html .html 30810 book/chapters/13-generics.html .html 28872 book/chapters/13-generiques.html .html 28902 book/chapters/14-macros.html .html 28913 book/chapters/15-pipeline.html .html 32428 book/chapters/16-interop.html .html 29500 book/chapters/16a-vitte-binding.html .html 29765 book/chapters/17-stdlib.html .html 32943 book/chapters/18-tests.html .html 29392 book/chapters/19-performance.html .html 29977 book/chapters/20-repro.html .html 29292 book/chapters/20-reproducibility.html .html 29322 book/chapters/20a-architecture-globale.html .html 32799 book/chapters/20a-overall-architecture.html .html 32709 book/chapters/21-cli-project.html .html 30252 book/chapters/22-http-project.html .html 30195 book/chapters/23-system-project.html .html 30249 book/chapters/24-kv-project.html .html 30173 book/chapters/25-arduino-project.html .html 30256 book/chapters/26-editor-project.html .html 30273 book/chapters/27-grammar.html .html 30798 book/chapters/28-conventions.html .html 30978 book/chapters/29-style.html .html 32459 book/chapters/30-faq.html .html 29629 book/chapters/31-build-errors.html .html 29631 book/chapters/32-modules-catalog.html .html 30840 book/chapters/33-suggested-chapters.html .html 31213 book/chapters/34-compiler-mental-model.html .html 30231 book/chapters/35-error-message-anatomy.html .html 30066 book/chapters/36-naming-strategies.html .html 31284 book/chapters/37-large-scale-module-conventions.html .html 31425 book/chapters/38-type-driven-refactoring.html .html 31673 book/chapters/39-stable-public-api-design.html .html 30298 book/chapters/40-breaking-compatibility.html .html 31657 book/chapters/41-versioning-and-migration.html .html 31397 book/chapters/42-robust-procedure-patterns.html .html 30273 book/chapters/43-vitte-code-anti-patterns.html .html 30426 book/chapters/44-measure-before-optimizing.html .html 30635 book/chapters/45-performance-allocations-copies.html .html 30646 book/chapters/46-adapted-data-structures.html .html 31972 book/chapters/47-reproducible-debugging.html .html 29643 book/chapters/48-tracing-and-observability.html .html 29918 book/chapters/49-readable-unit-tests.html .html 29744 book/chapters/50-scenario-integration-tests.html .html 29871 book/chapters/51-compiler-regression-tests.html .html 29830 book/chapters/52-grammar-valid-invalid-tests.html .html 29934 book/chapters/53-property-based-testing-parser.html .html 29986 book/chapters/54-source-fuzzing.html .html 29685 book/chapters/55-memory-safety-invariants.html .html 30250 book/chapters/56-defensive-io-programming.html .html 30260 book/chapters/57-semantic-error-handling.html .html 30223 book/chapters/58-ci-pipeline-for-vitte-project.html .html 30706 book/chapters/59-risk-oriented-code-review.html .html 29943 book/chapters/60-sustainable-technical-documentation.html .html 30141 book/chapters/61-grammar-diagram-generation.html .html 31315 book/chapters/62-", "lang": "en", "section": "docs" }, { "title": "Vitte Download", "path": "download.html", "content": "Vitte Download Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Vitte Download Quickly install, compile and verify with short, concrete steps. Welcome Documentation Visual Preview Sitemap Download Source Community News Diagnostics Suggestions Compiler Vitte The visible toolchain now follows the Vitte compiler surface end to end: the driver lives in Vitte source, the grammar and parser stay aligned, and the repo checks expect a Vitte-only tree. See what changed in the last 48 hours Read the compiler driver alignment notes Open the main documentation index Open source-backed HTML guides Quick Install brew install vitte (or build from source with make build ). Confirm binary path with which vitte . Run vitte --version and compare with this page release block. Example verification # after install vitte --version vitte check tests/strict_ok.vit vitte explain E0001 Use this page to install and then move quickly to diagnostics or docs when you want to confirm a command or version. Platforms Platform Status Notes Linux x86_64/arm64 Supported Primary CI path macOS Intel/Apple Silicon Supported Installer and source build paths Windows x86_64 Supported Toolchain verification via compatibility checks Version Verification vitte --version should match current release notes. vitte check tests/strict_ok.vit must complete without parser/runtime errors. make core-language-gate must pass for contributor-grade installs. Proof-First Snapshot Dernière mise à jour: May 14, 2026 Build ID / Commit: docs-v4 / main (see status.html) Known issues The verified quick-check path now uses tracked repository fixtures instead of absent example files. Cross-platform troubleshooting examples are being expanded. Compatibility matrix Component Status Check CLI binary Ready vitte --version Core compile path Ready vitte check Contributor gates Ready make core-language-gate Before you install Confirm which path you want: a release package, a local build, or a quick check of the current compiler behavior. The page keeps those choices separate so you can move straight to the action that matters. Read the current notes if you want the context. Install or build the toolchain if you want to run it locally. Use the diagnostics page if you need to verify a result or decode an error. Release Notes – Version 0.1.0 Date: February 18, 2026 Publication reference: Vitte2026_02 Installer : vitte-0.1.0.pkg Uninstaller : vitte-uninstall-0.1.0.pkg Included : binaries vitte , vittec , man pages, shell completions, runtime, and editor assets. Patch : the test internal_module_denied returns to the expected diagnosis E1016 . Recommended path Install : put down the tools and check the environment. Compile : compile, run the tests, prepare the output. Check : validate an example and read the diagnostics. Install brew install vitte make build make install Compile make build make test make core-language-gate Check vitte check tests/strict_ok.vit vitte explain E0001 make book-links-check Current state The current tracked compiler work is Vitte-only, with no legacy backend sources remaining in the active surface. CI is green on the fast and strict paths, so the download page mirrors a working toolchain rather than a placeholder state. The next obvious checks are the docs, the driver notes, and the news log, which all point to the same compiler surface. Doc shortcuts Read the full documentation See documentation notes Read the diagnostics Open Pocket Summary Open the Sitemap ← Previous Next → download.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Vitte Home", "path": "index.html", "content": "Vitte Home Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Vitte Home Compact entry point for project documentation, diagnostics, and announcements. Docs Build Version: v4 Date: 2026-05-09T15:51:11.977088+00:00 Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions Compiler Vitte The compiler is treated as a Vitte-owned surface, with the driver, grammar, and snapshot checks moving together as one repository path. Docs Open the documentation hub and top technical pages. Download Install the toolchain and verify your version. Visual preview Compare the README hero, compact mobile version, and social card. Community Contribute, discuss architecture, and follow roadmap. Get Started Install Vitte from the Download page . Open Documentation and start with top pages . Join Community for contribution workflow . Canonical project surface Use .vit for compiler and user source files. Use .vitl for library/stdlib modules. Treat .vitte as a legacy extension kept for editor compatibility. vitte check tests/strict_ok.vit vitte build tests/strict_ok.vit -o build/strict_ok vitte run tests/strict_ok.vit The VS Code extension and documentation now point at the same unified vitte CLI instead of old split binaries. Proof-First Snapshot Dernière mise à jour: May 14, 2026 Build ID / Commit: docs-v4 / main (see status.html) Known issues Some legacy pages still contain mixed EN/FR wording and are being normalized. Extended a11y checks are available but not enabled by default in docs smoke CI. Compatibility matrix Platform Status Notes Linux Supported Primary CI path macOS Supported Desktop and Apple Silicon workflow Windows Supported Toolchain and docs assets verified Where to begin If you are new here, the fastest path is simple: read the handbook, open the source view, then check the current news. If you are debugging something, start with diagnostics. If you are deciding what to do next, use the suggestions page. The site is organized so each page answers one question cleanly instead of forcing you through a long detour. Documentation for the compiler surface and the book. Source for the implementation path and current architecture notes. Diagnostics for fast error triage. Suggestions for the next practical action. Example: use this site # Pick the page that matches your goal 1. Read the feature: open doc.html 2. Inspect the code: open source.html 3. Debug issues: open diagnostics.html 4. Choose the next action: open suggestions.html # Search for a topic from the docs page open doc.html and type \"diagnostic\", \"parser\", or \"build\" in the search field # Confirm with a focused task run make quickstart-check or open news.html for the latest updates This example shows the intended site flow: learn from docs, inspect source, debug with diagnostics, then act with suggestions. To start up Install the tools Read the documentation Pocket Summary Read the book Open documentation Diagnostics Source Return to project Download News Community Shortcuts Documentation Sitemap Diagnostics Source Download ← Previous Next → index.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Vitte News", "path": "news.html", "content": "Vitte News Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Vitte News Short log of visible changes, documentation migrations and stdlib updates. @goginx news note: the current project focus is to turn headline capabilities into checked compiler contracts: lexer, parser, AST, LLVM native smoke, temporal ownership, and compile-time simulation now move forward through explicit gates, regression tests, and reports instead of unchecked roadmap claims. This page tracks those changes as public signals so contributors can see which features are proven, which ones remain scoped, and where to verify the implementation. Changelog Timeline Use this page to see what changed and why, then follow the related links to docs, source, or diagnostics. # Example use # 1. Read the latest release note here # 2. Open the matching docs or source page # 3. Verify behavior with diagnostics or a quick build Date Version Type Summary May 23, 2026 0.3.4 Compiler Health Added `metrics` and `health` JSON surfaces, advanced diagnostics helpers, parser recovery quality metrics, LSP stability suite, and local-change incremental invalidation domains. May 22, 2026 0.3.3 Compiler Delivery Professional seed delivery gates expanded (40→120): self-host baseline (`self-host-check`), strict refactor gate (`ci-gate --strict`), release/package/workspace commands, compatibility checks, and bootstrap/reproducibility documentation. May 22, 2026 0.3.2 Compiler Native panic boundary ABI wired end-to-end, linker now auto-includes runtime C payload, `CompilerLogger` added (`--verbose`, `--trace-pipeline`), and target alias matrix expanded for modern + legacy machine names. May 20, 2026 Strict Driver Gate Compiler compiler-max-gate-strict and selfhost-hard-strict now pass with entry lock, reachability audit, strict smokes, and real driver pipeline wiring. May 18, 2026 Compiler Structure Pass Architecture Frontend AST, HIR, MIR, lexer diagnostics, precedence parsing, and analysis entry points were rebuilt around real structured compiler data. May 14, 2026 Stdlib 2.0 Non-breaking Large stdlib expansion with async/threading/ffi/reflection/profiling/packages. May 09, 2026 Docs v4 Non-breaking Unified docs pipeline and stronger quality gates for links/assets. Feb 18, 2026 0.1.0 Patch Diagnostic fix for E1016 path and installer refresh. Breaking policy: any breaking change must explicitly mark migration notes and acceptance criteria. Proof-First Snapshot Dernière mise à jour: May 22, 2026 (0.3.3) Build ID / Commit: docs-v4 / main (see status.html) Known issues Some historical entries are longer than needed and will be compacted. Duplicate CSP tag is still present in this page header and should be cleaned in next pass. Compatibility matrix Consumer Status Notes Users Stable Patch and release notes available Contributors Stable Roadmap and evidence links available CI/Automation Stable Docs gates integrated in workflows Fast Technical Feed @goginx update: focus shifted to measurable compiler health and local-change incremental recompilation guarantees, with new metrics/health surfaces and stronger recovery + LSP stability contracts. Delivery gates: seed command surface now includes `release`, `package`, `workspace`, `compat-check`, `migrate`, `stress`, and `ci-gate --strict` with report outputs under `build/reports`. Self-host: seed-to-generation consistency checks now produce deterministic audit reports under target/selfhost_completion/ . Release engineering: release archive generation + SHA256 verification flow is now available from compiler CLI (`release build|verify`). Runtime ABI: panic boundary primitives are now explicitly declared and implemented for native runtime integration. Link step: runtime C payload auto-wiring is now part of linker artifact generation path. Targets: compiler target normalization accepts a wider matrix of modern and legacy aliases for old-machine compatibility flows. Compiler strictness: entry lock + diagnostics migration gate + reachability audit are now part of strict compiler quality flow. Docs pipeline: single chain build_docs_site → build_grammar_extras → sync_ebnf_memory_pages → build_static_extras → checks . Policy: EN-only output, canonical/hreflang stabilized, vitte-lang.org normalized. Search: weighted ranking (title x3, path x2, content x1), filters, keyboard nav, URL state persistence. Quality gates: broken links, duplicate script/css, html size, perf budget, docs doctor, pedagogy progressive gate. Offline: service worker + offline fallback page + critical assets cache. Welcome Documentation Visual Preview Sitemap Download Source Community News Diagnostics Suggestions May 18, 2026 Latest Modifications: Structured Compiler Pipeline Rebuild Latest modification: the compiler no longer pretends to carry structure through the frontend and middle-end. The latest pass rebuilt the pipeline around explicit compiler dat", "lang": "en", "section": "docs" }, { "title": "Offline", "path": "offline.html", "content": "Offline Skip to content ⚠ You are offline Network status: offline Last docs build: 2026-07-18T06:21:23.782237+00:00 This page is lightweight and available without network. Retry Back to home Documentation Pages available offline index.html doc.html status.html offline.html search-index.json css/site.css css/layout.css js/main.js js/offline-status.js svg/logo.svg svg/sprite.svg", "lang": "en", "section": "docs" }, { "title": "Vitte Roadmap 161-200 (Version Pro)", "path": "roadmap_161_200_pro.html", "content": "Vitte Roadmap 161-200 (Version Pro) Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Vitte Roadmap 161-200 (Pro Version) Steering framework Scope: Complete Vitte's transition from an advanced compiler to a complete language platform, without sacrificing reliability. Guiding principle: any added complexity must remain strictly lower than the system confidence it provides. Definition of done global: measurable functional impact readable and actionable diagnostics non-regression and robustness tests synchronized technical documentation risque residuel explicite et accepte Strategic streams Stream A - Type System, Inference, Generics, Traits (161-165, 168) 161. Advanced Type Inference Objective: improve ergonomics without loss of static safety. Deliverables: inference of local variables inference of simple returns coherent propagation of constraints unique unification engine precise ambiguity diagnostics explicit fallback rules Acceptance: no soundness regression on the typing suite ambiguity diagnostics with concrete suggestion 162. Generics Foundation Objective: introduce controlled and predictable generics. Deliverables: generic parameters type substitution minimal monomorphization simple constraints (base bounds) clear generic diagnostics Acceptance: generic standard examples compile localized constraint errors with reliable spans 163. Generic Monomorphization Objective: generate specialized instances without unnecessary duplication. Deliverables: instance cache deterministic specialization keys elimination of duplicates MIR specialization backend specialization Acceptance: deterministic build for same inputs reduction of duplicates verified by metrics 164. Trait / Interface Foundation Objective: provide a stable typical abstraction. Deliverables: definitions of traits/interfaces method resolution verification of impl recovery diagnostics minimum line bounds Acceptance: consistency of impl guaranteed resolution ambiguity properly reported 165. Dynamic Dispatch Support Objective: support runtime polymorphism safely. Deliverables: vtables fat pointers runtime dynamic dispatch verification object safety Stable ABI for dyn types Acceptance: valid dyn calls on supported targets explicit rejection of non-object-safe cases 168. Const Generics Foundation Objective: support constant parameters in types. Deliverables: const parameters integration eval const generic tables overflow diagnostics Acceptance: deterministic const evaluation reproducible and understandable overflow errors Stream B - Pattern Semantics & Completeness (166-167) 166. Advanced Pattern Matching Objective: make the match robust and complete. Deliverables: completeness check detection of unreachable branches nested patterns guards (if active) correction-oriented diagnostics Acceptance: no false negative criticism on completeness dead branches precisely detected 167. Exhaustiveness Engine Objective: ensure full coverage of variants. Deliverables: decision tree variant coverage wildcard analysis unreachable detection Acceptance: reusable engine for match / select complexity mastered on large enums Stream C - Macro & Frontend Pipeline (169-170) 169. Macro System Foundation Objective: add metaprogramming without weakening the language. Deliverables: hygienic macros token expansion recursion limits diagnostics with macro spans trace of expansion Acceptance: hygiene validated in case of name capture recursion stopped with actionable message 170. Macro Expansion Pipeline Objective: integrate the expansion into the frontend in a stable manner. Target pipeline: source -> lexer -> macro expand -> parser -> AST Verifications: correct spans from start to finish diagnostics preserved after expansion recursion protection safe Stream D - Async, Coroutines, Concurrency (171-174) 171. Async Foundation Objective: establish async primitives. Deliverables: async functions lowering towards futures lowering await async MIR support async misuse diagnostics 172. Coroutine Lowering Goal: convert async to reliable state machine. Deliverables: Generator MIR ellipsis/resume captures of premises drop safety 173. Concurrency Memory Model Objective: formalize concurrent memory behavior. To document: atomics synchronization inter-thread visibility ordering rules data-race guarantees 174. Parallel Borrow Analysis Objective: make borrow checking parallel compatible. Deliverables: equivalents Send / Sync shared mutation checks thread ownership rules competition diagnostics Stream E - Backends, ABI, Perf, Execution Modes (175-181) 175. Advanced Optimization Passes inline, loop simplification, branch folding, scalar replacement, dead store elimination, value numbering. Acceptance: measurable gains on reference benches without semantic regression. 176. LLVM Backend Experimental LLVM IR emission, metadata debug, optimization bridge, target lowering, integration linker. Acc", "lang": "en", "section": "docs" }, { "title": "Vitte Roadmap 161-200 (Professional Edition)", "path": "roadmap_161_200_pro_en.html", "content": "Vitte Roadmap 161-200 (Professional Edition) Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Vitte Roadmap 161-200 (Professional Edition) Program frame Scope: complete Vitte's transition from advanced compiler to full language platform without compromising reliability. Guiding principle: any added complexity must stay lower than the reliability confidence it creates. Global definition of done: measurable functional impact actionable diagnostics quality non-regression and robustness tests synchronized technical documentation explicit residual-risk statement Strategic streams Stream A - Type System, Inference, Generics, Traits (161-165, 168) Advanced Type Inference local variable inference simple return inference constrained propagation unified unification engine ambiguity diagnostics explicit fallback rules Generics Foundation generic parameters substitution type minimal monomorphization simple constraints generic diagnostics Generic Monomorphization instance cache deterministic specialization keys duplicate elimination MIR specialization backend specialization Trait/Interface Foundation trait definitions method resolution impl checking overlap diagnostics minimal trait bounds Dynamic Dispatch Support vtables fat pointers runtime dispatch object-safety checks ABI-stable dyn types Const Generics Foundation const parameters const-eval integration generic arrays overflow diagnostics Stream B - Pattern Semantics (166-167) Advanced Pattern Matching exhaustiveness checks unreachable arm detection nested patterns guards (if enabled) pattern diagnostics Completeness Engine decision tree variant coverage wildcard analysis unreachable branch detection Stream C - Macro and Frontend Pipeline (169-170) Macro System Foundation hygienic macros token expansion recursion limits macro-span diagnostics trace expansion Macro Expansion Pipeline source -> lexer -> macro expand -> parser -> AST verify span correctness preserve diagnostics fidelity recursion-safe behavior Stream D - Async, Coroutines, Concurrency (171-174) Async Foundation Coroutine Lowering Concurrency Memory Model Parallel Borrow Analysis Stream E - Backends, ABI, Performance, Execution (175-181) Advanced Optimization Passes LLVM Backend Experimental Native ASM Backend Register Allocator Low-level ABI Test Suite JIT Foundation MIR Interpret Stream F - Tooling Platform (182-185) Compile Embedding API IDE Integration Complete Refactor Engine Advanced Formatter Stream G - Analysis, Safety, Security (186-189) Static Analysis Framework Security Analysis Passes Unsafe Code Model Verified Unsafe Boundaries Stream H - Runtime, Interop, Targets, Research, Formalization, Platform (190-200) Advanced Runtime Services GC Experimental Mode Foreign Function Interface Bindgen Foundation Embedded Target Support Kernel Mode Foundation Compile Research Sandbox Verified Compiler Pipeline Formal Semantic Model Vitte Language Platform Vitte Platform Complete Foundation Mandatory completion checklist for 200: stable compile credible self-host path real backend professional diagnostics complete tooling baseline maintainable stdlib/runtime minimal ecosystem package IDE support deterministic builds active replay/debug/fuzz/stress workflows strong technical documentation verified minimum security baseline extensible architecture defined technical governance Final rule: Added complexity must remain lower than gained system reliability confidence. ← Previous Next → roadmap_161_200_pro_en.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Vitte Roadmap 161-200: Execution Plan by Quarter", "path": "roadmap_161_200_quarterly.html", "content": "Vitte Roadmap 161-200: Execution Plan by Quarter Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Vitte Roadmap 161-200: Execution Plan by Quarter Planning assumptions Horizon: 8 quarters (24 months), with rolling re-baseline every quarter. Rule: no milestone closes without tests, diagnostics quality checks, and updated docs. Governance gate: added complexity must remain below reliability confidence gained. Quarter-by-quarter plan Q1 - Type safety core hardening Scope: 161 Advanced Type Inference 162 Generics Foundation 164 Trait / Interface Foundation (minimal) 166 Advanced Pattern Matching 167 Exhaustiveness Engine 188 Unsafe Code Model (baseline policy) Exit criteria: typing soundness regressions: 0 exhaustive match checks enabled on stable surface unsafe diagnostics available with explicit spans Q2 - Expressiveness without trust erosion Scope: 163 Generic Monomorphization 165 Dynamic Dispatch Support 168 Const Generics Foundation 169 Macro System Foundation 170 Macro Expansion Pipeline Exit criteria: deterministic specialization cache behavior object safety checks in dyn dispatch macro expansion keeps source-level diagnostics fidelity Q3 - Async and concurrency semantics Scope: 171 Async Foundation 172 Coroutine Lowering 173 Concurrency Memory Model 174 Parallel Borrow Analysis Exit criteria: async lowering correctness suite green concurrency model published and versioned thread-safety diagnostics integrated in CI Q4 - Performance and machine correctness Scope: 175 Advanced Optimization Passes 178 Register Allocator 179 Low-level ABI Test Suite 181 MIR Interpret Exit criteria: measurable benchmark gains on reference corpus ABI suite passing on primary targets MIR interpreter usable for debug/repro workflows Q5 - Backend expansion and execution modes Scope: 176 LLVM Backend Experimental 177 Native ASM Backend 180 JIT Foundation Exit criteria: experimental backends isolated behind feature flags ABI parity checks defined per backend path JIT path operational on constrained subset Q6 - Developer platform maturity Scope: 182 Compiler Embedding API 183 IDE Integration Complete 184 Refactor Engine 185 Advanced Formatter Exit criteria: embedding API with stable callback contracts IDE diagnostics incremental pipeline usable at scale formatter deterministic across repeated runs Q7 - Analysis, security, runtime/interop targets Scope: 186 Static Analysis Framework 187 Security Analysis Passes 189 Verified Unsafe Boundaries 190 Advanced Runtime Services 192 Foreign Function Interface 193 Bindgen Foundation Exit criteria: baseline security checks integrated in release gate unsafe audit trail generated and reviewable FFI ABI mismatch diagnostics validated on fixtures Q8 - Long-term confidence and platform completion Scope: 191 GC Experimental Mode 194 Embedded Target Support 195 Kernel Mode Foundation 196 Compiler Research Sandbox 197 Verified Compiler Pipeline 198 Formal Semantic Model 199 Vitte Language Platform 200 Vitte Platform Complete Foundation Exit criteria: formal model baseline published verified-pipeline checks active in CI platform checklist for 200 reviewed and signed off Ongoing every quarter Reliability KPIs: soundness, determinism, crash-free compile rate. Docs sync: architecture, diagnostics, and status pages aligned with shipped behavior. Risk review: complexity budget reviewed at each quarterly close. ← Previous Next → roadmap_161_200_quarterly.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Search", "path": "search.html", "content": "Search Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Search Use the search box in the header with filters (section and language). If JavaScript is disabled, use the sitemap . ← Previous Next →", "lang": "en", "section": "docs" }, { "title": "Seed Diagnostics Surface", "path": "seed_diagnostics.html", "content": "Seed Diagnostics Surface Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Seed Diagnostics Surface This page documents the current diagnostics contract implemented by the stage0 bootstrap seed in both forms: executable shell seed: toolchain/seed/vittec0.seed canonical readable Vitte source: toolchain/seed/src/main.vit Required Phases Every seed diagnosis must declare a phase. The supported phase names are: lexer parser ast_validation module_resolution symbol_resolution sema typeck borrowck mir_lowering mir_verification backend linker runtime_execution Phase-less bootstrap messages are not part of the accepted diagnostics surface. Lexer Coverage The seed surface currently covers these lexer errors: LEX_E_INVALID_CHAR LEX_E_UNTERMINATED_STRING LEX_E_INVALID_CHAR_LITERAL LEX_E_INVALID_ESCAPE LEX_E_INVALID_UNICODE LEX_E_INVALID_NUMBER LEX_E_UNTERMINATED_COMMENT LEX_E_TOKEN_TOO_LARGE Expected payload quality: exact failing character or token line and column byte-oriented hint when the shell surface can compute it direct correction help Parser Coverage The bootstrap subset currently reports: PARSE_E_TOPLEVEL_DECL_EXPECTED PARSE_E_INCOMPLETE_EXPR PARSE_E_UNCLOSED_BLOCK PARSE_E_MISSING_RPAREN PARSE_E_MISSING_COMMA PARSE_E_TYPE_EXPECTED PARSE_E_PATTERN_EXPECTED PARSE_E_BLOCK_EXPECTED Expected payload quality: expected token found token syntax context recovery applied or not Module Resolution Coverage The bootstrap subset currently reports: MOD_E_MODULE_NOT_FOUND MOD_E_IMPORT_NOT_FOUND MOD_E_IMPORT_CYCLE MOD_E_SYMBOL_NOT_EXPORTED MOD_E_PACKAGE_MISSING MOD_E_STDLIB_MISSING MOD_E_AMBIGUOUS_MODULE Expected payload quality: import chain tested paths request module closest-name or closest-path hint Symbol Resolution Coverage The bootstrap subset currently reports: SEMA_E_UNKNOWN_IDENTIFIER SEMA_E_AMBIGUOUS_SYMBOL SEMA_E_DUPLICATE_SYMBOL SEMA_E_SHADOWING_FORBIDDEN SEMA_E_UNKNOWN_FIELD SEMA_E_UNKNOWN_VARIANT SEMA_E_UNKNOWN_FUNCTION Expected payload quality: current scope closest symbol original declaration for duplicates active imports Surfaces Shell seed toolchain/seed/vittec0.seed exposes: human-readable text diagnostics JSON diagnostics with schema = "vitte.compiler.surface" pipeline_failed_at primary_report phase_reports Vitte seed toolchain/seed/src/main.vit exposes: diagnostics_text_for_source(source_name, source) diagnostics_json_for_source(source_name, source) CLI-like entry points via run_seed_cli(args) diag <file> diag-json <file> check <file> The Vitte surface is aligned structurally with the shell seed and is intended to converge toward identical codes and messages for every covered bootstrap case. ← Previous Next → seed_diagnostics.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "SEO Report", "path": "seo-report.html", "content": "SEO Report Skip to content SEO Report Pages without <title> CONTRIBUTING.html Pages without <meta name=\"viewport\"> accessibility-report.html changelog.html dashboard.html CONTRIBUTING.html docs-tree.html seo-report.html site-statistics.html grammar/pipeline.html grammar/status.html grammar/railroad_index.html grammar/pocket.html grammar/statistics.html grammar/grammar_inventory.html grammar/search.html grammar/diff.html book/book-health.html reports/architecture-docs-report.html reports/index.html Pages without canonical link accessibility-report.html offline.html status.html changelog.html 404.html CONTRIBUTING.html docs-tree.html site-statistics.html broken-links.html grammar/pipeline.html grammar/status.html grammar/index.html grammar/toolbox.html grammar/railroad_index.html grammar/pocket.html grammar/statistics.html grammar/precedence.html grammar/grammar_inventory.html grammar/search.html grammar/diff.html audits/memory_safety.html spec/grammar.html spec/type_system.html spec/language.html spec/ownership.html spec/normative.html release/compatibility_matrix.html profiling/PHASE_A_BASELINE_PLAN.html book/stdlib.html book/checklist.html book/status.html book/index.html book/book-health.html book/roadmap-pedagogique.html book/glossary.html book/start-30-min.html book/cli.html book/STYLE.html book/classic-mistakes.html book/technical-index.html book/errors.html book/ci.html book/compiler-stdlib-contract.html book/summary.html governance/long_term_ecosystem_maintenance.html governance/platform_maturity_baseline.html governance/README.html governance/platform_governance_complete.html beta_program/GUIDELINES_AND_NDA.html beta_program/CANDIDATE_SOURCING.html beta_program/ONBOARDING_PACK.html compiler/stdlib.html compiler/build.html compiler/pipeline.html compiler/stress_and_stability.html compiler/parallel_borrow_analysis.html compiler/sanitizers.html compiler/mir.html compiler/release_engineering.html compiler/borrowck.html compiler/macro_expansion_pipeline.html compiler/security_limits.html compiler/COMPILER_POWER_ROADMAP.html compiler/advanced_optimization_passes.html compiler/llvm_backend_experimental.html compiler/native_asm_backend.html compiler/coroutine_lowering.html compiler/diagnostics.html compiler/async_foundation.html compiler/concurrency_memory_model.html compiler/migration_and_editions.html compiler/type-system.html compiler/diagnostics_migration.html reports/architecture-docs-report.html reports/index.html reports/architecture-docs-summary.html beta_program/feedback_collection/TESTER_DEPLOYMENT_PLAN.html beta_program/feedback_collection/MONITORING_AND_METRICS.html beta_program/feedback_collection/WEEKLY_SYNC_TEMPLATE.html beta_program/bug_fixing_iteration/RETEST_REPORT.html beta_program/bug_fixing_iteration/FIX_PLAN.html beta_program/bug_fixing_iteration/TRIAGE.html beta_program/bug_fixing_iteration/FEATURE_REQUEST_TOP3.html book/grammar/decls.html book/grammar/grammar-notes.html book/grammar/index.html book/grammar/stmts.html book/grammar/grammar-changelog.html book/grammar/precedence.html book/grammar/lexical.html book/grammar/types.html book/grammar/expr.html book/logique/types-et-contrats.html book/logique/index.html book/logique/matching.html book/logique/conditions.html book/logique/boucles.html book/logique/expressions.html book/poche/00-how-to-read.html book/poche/06-modules.html book/poche/index.html book/poche/10-roadmap.html book/poche/02-variables-and-types.html book/poche/09-mini-cli-project.html book/poche/checklist-before-publication.html book/poche/05-structures.html book/poche/01-first-program.html book/poche/04-procedures.html book/poche/07-reading-errors.html book/poche/08-essential-tests.html book/poche/03-conditions-and-loops.html book/poche/summary.html book/stdlib-reference/modules/compiler--backends--ast--target_expr.vit.html book/stdlib-reference/modules/compiler--ir--hir.vit.html book/stdlib-reference/modules/compiler--driver--options.vit.html book/stdlib-reference/modules/compiler--backends--ast--target_stmt.vit.html book/stdlib-reference/modules/compiler--ir--mir.vit.html book/stdlib-reference/modules/compiler--backends--emit--emit.vit.html book/stdlib-reference/modules/compiler--backends--lower--lower_mir.vit.html book/stdlib-reference/modules/compiler--frontend--parser.vit.html book/stdlib-reference/modules/compiler--driver--compiler.vit.html book/stdlib-reference/modules/compiler--driver--pipeline.vit.html book/stdlib-reference/modules/compiler--backends--toolchain--arduino.vit.html book/stdlib-reference/modules/compiler--backends--ast--target_decl.vit.html book/stdlib-reference/modules/compiler--backends--context--backend_context.vit.html book/stdlib-reference/modules/compiler--driver--mod.vit.html book/stdlib-reference/modules/compiler--tests--smoke.vit.html book/stdlib-reference/modules/compiler--frontend--lexer.vit.html book/stdlib-reference/modules/compiler--frontend--token.vit.html book/stdlib-reference/modules/compiler--ir--lower.vit.html book/", "lang": "en", "section": "docs" }, { "title": "Site Statistics", "path": "site-statistics.html", "content": "Site Statistics Skip to content Site Statistics Total HTML pages: 559 Total assets: 20 Total CSS files: 7 Total JS files: 13 Total SVG files: 567 Total JSON files: 263 Build date (UTC): 2026-07-18T06:18:37.717027+00:00 ← Previous Next →", "lang": "en", "section": "docs" }, { "title": "Sitemap", "path": "sitemap.html", "content": "Sitemap Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Sitemap Compact map of the public site, grouped by task and reading path. Welcome Documentation Sitemap Source Entry points Home Documentation Download Source Source Guides Diagnostics Community News Suggestions Book Book Home Main Summary Pocket Book Pocket Summary Technical Index Glossary Editorial Checklist Classic Mistakes Error Guide CLI Guide Language and compiler Grammar Compiler Pipeline Overall Architecture Compiler Mental Model AST to IR Grammar Precedence Grammar Declarations Grammar Expressions Support and change log Migration notes Source-backed guides News Diagnostics Community ← Previous Next → sitemap.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Vitte Visual Preview", "path": "social-preview.html", "content": "Vitte Visual Preview .preview-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); gap: 1.5rem; margin-top: 1.5rem; } .preview-card { background: var(--surface-raised, #fff); border: 1px solid rgba(22, 43, 69, 0.12); border-radius: 18px; padding: 1rem; box-shadow: 0 12px 30px rgba(12, 25, 44, 0.08); } .preview-card h2 { margin-top: 0; } .preview-frame { background: linear-gradient(180deg, #edf3f6 0%, #ffffff 100%); border-radius: 14px; padding: 0.75rem; overflow: auto; } .preview-frame img { width: 100%; height: auto; display: block; border-radius: 12px; } .preview-meta { color: #526578; font-size: 0.95rem; } .preview-links { display: flex; flex-wrap: wrap; gap: 0.75rem; margin-top: 0.75rem; } Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Vitte Visual Preview Quick comparison page for the repository visual assets used in the root README and social sharing surfaces. What this page is for Use this page to compare the large README hero, the compact mobile-first version, and the social card without opening the SVG files one by one. Open README Main hero SVG Compact hero SVG Social card SVG Main Hero Best for the desktop GitHub README header. Compact Hero Better for narrow layouts and mobile previews. Social Card Optimized for link sharing, Open Graph style previews, and announcement cards. ← Previous Next → social-preview.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Source Guides", "path": "source-guides.html", "content": "Source Guides Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Source Guides Static HTML reading pages for source-backed operational documentation. Documentation Source Sitemap Migration Notes How to read this section Use the HTML pages below for normal reading. Each page exposes its original Markdown source and rewrites internal Markdown links to HTML whenever a matching reader page exists. Bootstrap Bootstrap Contracts with the source at bootstrap_contracts.md . Bootstrap Migration Checklist with the source at bootstrap_migration_checklist.md . Bootstrap Native IR v1 with the source at bootstrap_native_ir.md . Bootstrap Seed Contract with the source at bootstrap_seed.md . Vitte Native Bootstrap Migration with the source at BOOTSTRAP_NATIVE_MIGRATION_FROM_RUST.md . Bootstrap Vitte File Mapping with the source at BOOTSTRAP_VITTE_FILE_MAPPING.md . Compiler Reference Compiler Driver Alignment with the source at COMPILER_DRIVER_MIGRATION.md . Make Targets with the source at MAKE_TARGETS.md . Module Reference with the source at MODULE_REFERENCE.md . Package Index and Package Maturity remain first-class HTML pages in the main docs flow. Beta Program Candidate Sourcing Guidelines and NDA Onboarding Pack Feature Request Top 3 Fix Plan Retest Report Triage Monitoring and Metrics Tester Deployment Plan Weekly Sync Template Profiling Phase A Baseline Profiling with the source at profiling/PHASE_A_BASELINE_PLAN.md . ← Previous Next → source-guides.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Vitte Source", "path": "source.html", "content": "Vitte Source Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Vitte Source Repository organization, contribution flow, and entry points for developers. Pipeline Compiler Model Parse AST to IR Visual Preview Railroad SVG Sitemap Compiler Vitte The source view reads the project through the Vitte compiler stack: driver surface, grammar surface, snapshots, and repo checks are aligned around the same code paths. Driver alignment Review the driver alignment notes. Compiler flow See the pipeline from parser to backend. Visual assets Preview the README hero, compact mobile asset, and social card. Source guides Open the HTML reader pages for source-backed docs. Understanding the compiler The Vitte compiler reads as a series of simple layers: parser, resolution, IR, then backend, with the driver and linting surface expressed in the same language as the rest of the repository. Parser : reads the code and builds the AST. Resolution : connects names, imports and symbols. IR : lowers to an intermediate representation. Backend : produces the target code. Example read path # Read the parser entry point open src/vitte/compiler/frontend/parse/parser.vit # Read the HIR/MIR lowering path open src/vitte/compiler/middle/lower/mod.vit # Inspect the bootstrap contracts in docs open docs/bootstrap_seed.html This example shows how to follow the source path from parser, through lowering, to bootstrap and documentation contracts. Flow Main flow: source -> parser -> AST -> resolve -> IR -> backend -> output Reading errors: diagnostic -> layer -> cause -> minimal fix -> rerun Current compiler notes The driver implementation lives under src/vitte/compiler/driver . The grammar and parser sync work now point at src/vitte/grammar/vitte.ebnf and the parser coverage report. Repo-level checks such as package layout, legacy import lint, and docs path checks are tuned to the Vitte-only tree. Useful references Compiler Pipeline Overall Architecture AST Mapping -> IR Bootstrap Native IR Bootstrap Seed Contract Module Reference Grammar Diagrams Grammar Reference Railroad SVG Source-backed reading paths Source guides index Bootstrap Contracts Bootstrap Migration Checklist Bootstrap file mapping Governance and long-term maintenance Governance pack index Long-term ecosystem maintenance Platform governance complete Platform maturity baseline Release engineering Migration and editions Version compatibility matrix Contribute Read CONTRIBUTING.html Open the Sitemap Open the Book Home Open the Technical Index Prepare a short patch, then restart validation. References Discuss Debug Track changes Read SUPPORT.html ← Previous Next → source.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Start Here", "path": "start-here.html", "content": "Start Here Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Start Here If you are new, follow this order: Install Read Documentation Use Diagnostics Need full map? Open Sitemap . Want the visual overview first? Open Visual Preview . Current Vitte surface .vit is the canonical compiler/user source extension. .vitl is used for library and stdlib modules. .vitte remains a legacy/editor compatibility extension. The primary CLI is vitte : use check , build , run , parse , and explain . vitte check tests/strict_ok.vit vitte build tests/strict_ok.vit -o build/strict_ok vitte run tests/strict_ok.vit Quick example After installation, verify the site locally by opening docs/index.html in your browser. For documentation edits, change the HTML file directly in docs/ and refresh the page. Site edit example # edit the landing page or a docs page open docs/index.html # or edit an existing site page code docs/suggestions.html # preview in browser after saving open docs/index.html This is the intended workflow for site authors: edit the HTML in docs/ , then refresh the browser to see the result. If you want the page to reload automatically while editing, open it with ?dev-refresh=1&refresh=5 . For production hosting, the static docs site now also ships a docs/_headers policy so HTML, CSS, JS, search indexes, and SVG assets all revalidate aggressively instead of sticking to stale browser cache. ← Previous Next →", "lang": "en", "section": "docs" }, { "title": "Docs Status", "path": "status-public.html", "content": "Docs Status Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Documentation Status Build version: v1 Last build (UTC): 2026-07-18T06:18:37.717027+00:00 Generated pages: 559 Assets tracked: 20 Checks Search index generated Sitemap and robots generated Checksums generated Grammar sync and docs checks expected in CI Open technical status (JSON view) ← Previous Next → status-public.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Site Health", "path": "status.html", "content": "Site Health Skip to content Vitte Welcome Documentation Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Site Health Docs Build Status Version: v1 Date: 2026-07-18T06:18:37.717027+00:00 { \"built_at_utc\": \"2026-07-18T06:18:37.717027+00:00\", \"pages\": 559, \"asset_count\": 20, \"checksums\": { \"css/content.css\": \"91a520b99cb08f73b736b13d1d6617c3b671843171de12e15b938de13ee07773\", \"css/code.css\": \"656afda91e9634e0d85feca25b68783eb111804ccea1268659b698ee764dde77\", \"css/theme-classic.css\": \"663b97c75b26e8cbe9be4c326694083f53449bfb95d76a251fa06d443dfe28b2\", \"css/site.css\": \"34fa1e8389296bcb6019f659bf3cda36a72f59b1339e70d2dd00e17645f510c7\", \"css/layout.css\": \"64061758862a22b472792f2c99bb2c911a9853d1516b6077df78895c4032bd49\", \"css/print.css\": \"ca626876df7d70a699bee68bd373d858e199ff57a8e4852bb05e77b02d88bbcf\", \"css/base.css\": \"5b1a3f069e7e0247ca70fc6a7319fd9ec1d3f5a0be73bde599dfc25dca0d4652\", \"sw.js\": \"06c4eedd0a8d185a1e0872effce923e17760adc245aa2761f21bef72af932cb2\", \"js/grammar-toolbox.js\": \"4a24688a27cc6399312f3975b4c98b37023d290ce5297ae6492d499452e7c200\", \"js/book-learning.js\": \"0475c0efef421dd899bfec4ad698b6a12e01faf396208af80afc094d0be54350\", \"js/offline-status.js\": \"476093a3a2ff3fc5285f7170e58efc5b6e59db5fd4c500b2cde3223f49fe12ea\", \"js/telemetry.js\": \"0c7e2a90ee1b695dfe0d9afb974a90708e0237fcddb68d5f4116881f9204d36e\", \"js/reading.js\": \"0417b524d2eacfe0b81d87057bc53f87c08cbfede558e0116b116917660a95e0\", \"js/main.min.js\": \"008bc1c1b509c4da0a791966c0d71931c16530b6cc1db69e7a63b1239809682e\", \"js/main.js\": \"28b2516d9c4749d650b8c8b1c2dc18d59f7e42ab2f3ad7ed312e05f9b26e958a\", \"js/site-interactions.js\": \"352665c8096b647fe83015f21b4ec6485d8a483bf3595e0c8a5113139cbd09b7\", \"js/anchors.js\": \"c984a750c0c6613c8af3afe0ba2a040248d389809449f00275193c64742692f5\", \"js/keyword-viewer.js\": \"0acc1a6c0b8d377c66f87b6d0ed6c32e30cb579d5742250e67c813abab3362a2\", \"js/nav.js\": \"cdc259907d9043511bbde7dd7ad3de1502987e79f0391b2188e0eac0c4a69502\", \"js/book-status.js\": \"7636a7c5f432ecd64a9ff0ce4fa1972f70e1c512e9e63fc2ee2648f1dc757577\" } } status.html Back to home", "lang": "en", "section": "docs" }, { "title": "Vitte Suggestions", "path": "suggestions.html", "content": "Vitte Suggestions Skip to content Vitte Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions All sections Docs Book Grammar All languages EN FR Suggestions Vitte Short tracks for choosing what to read, what to test, what to fix, and what to publish first. Welcome Documentation Visual Preview Download Source Community News Diagnostics Suggestions Read Open documentation Test Install the tools Debug Open diagnostics Contribute Read source Release See the Markdown migration note Example # Start with a single action make quickstart-check # Then narrow to a failing diagnostic or a documentation update Use this pattern to keep changes small and reviewable: one main action before branching to a deeper follow-up. Simple rule: only one main action per block, then we refine only if the context requires it. How to choose When the project feels busy, pick the smallest block that moves the work forward. If you need to understand a feature, start with Documentation . If you need to prove the behavior, go to Diagnostics . If you need the current implementation, open Source . If you need the latest project context, read News . The suggestion page exists to keep the next action obvious. The general order is stable: Read the page that describes the rule. Check the implementation or the error path that enforces it. Run the smallest test that can confirm the behavior. Only then broaden the change to docs, examples, or release notes. Suggestion list Read : Open Documentation for the current feature or rule. Inspect : Open Source and follow the implementation path. Verify : Open Diagnostics and match the error message before fixing. Test : Use a focused command like make quickstart-check or a targeted test file. Document : Add an example or explanation to the HTML page when the behavior is not obvious. Release : Update News or migration notes only after the change is confirmed. This keeps the work easy to review and easy to explain. It also keeps the repository honest: every suggestion should point toward a concrete artifact, not just a vague intention. ← Previous suggestions.html Back to home · Public status", "lang": "en", "section": "docs" }, { "title": "Vitte EBNF Memory Guide (EN)", "path": "vitte-ebnf-memory.html", "content": "Vitte EBNF Memory Guide (EN) Skip to content Vitte EBNF Memory Guide (EN) Source of truth: src/vitte/grammar/vitte.ebnf . Checksum (SHA-256): 4493876f55f9d93e4b5dd3dccc15a337693deb68955e9952648866ba8a8230f6 Prompt Contract Use only this grammar as source of truth. If unsure, answer: unknown. Validate rule by rule with production names. Return compliant/non-compliant with evidence. Provide minimal valid/invalid examples per rule. <<< ========================================================= Vitte — Complete Core Grammar systems + application + kernel + compiler surface canonical blocks: { } canonical syntax source for parser/docs/tests low-level capable compiler-capable no aliases, reduced duplicates ========================================================= >>> program ::= WS? { toplevel WS? } EOF ; <<< ================= Top-level ================= >>> toplevel ::= inner_attribute | space_decl | use_decl | export_decl | const_decl | static_decl | global_decl | type_alias_decl | opaque_type_decl | extern_type_decl | form_decl | class_decl | union_decl | bits_decl | pick_decl | flags_decl | trait_decl | impl_decl | extern_block | proc_decl | intrinsic_decl | compiler_decl | query_decl | pass_decl | backend_decl | diagnostic_decl | macro_decl | comptime_decl | static_assert_decl | test_decl | bench_decl | entry_decl ; space_decl ::= "space" WS1 module_path ; use_decl ::= "use" WS1 package_path [ use_group | use_glob ] [ WS1 "as" WS1 ident ] ; use_glob ::= "." "*" ; use_group ::= "." "{" WS? ( "*" | import_items [ WS? "," WS? "*" ]? ) WS? "}" ; import_items ::= import_item { WS? "," WS? import_item } [ WS? "," ] ; import_item ::= ident [ WS1 "as" WS1 ident ] ; export_decl ::= "export" WS1 ( "*" | ident_list | "{" WS? ident_list WS? "}" ) ; const_decl ::= { attr_prefix WS? } "const" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ; static_decl ::= { attr_prefix WS? } "static" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ; global_decl ::= { attr_prefix WS? } "global" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ; type_alias_decl ::= { attr_prefix WS? } "type" WS1 ident [ generic_params ] WS? "=" WS? type_expr ; opaque_type_decl ::= { attr_prefix WS? } "opaque" WS1 "type" WS1 ident [ generic_params ] [ WS? "=" WS? type_expr ] ; extern_type_decl ::= { attr_prefix WS? } "extern" WS1 "type" WS1 ident [ generic_params ] [ WS? ";" ] ; form_decl ::= { attr_prefix WS? } "form" WS1 ident [ generic_params ] [ WS? where_clause ] WS? "{" WS? form_items? WS? "}" ; class_decl ::= { attr_prefix WS? } "class" WS1 ident [ generic_params ] [ WS? where_clause ] WS? "{" WS? class_items? WS? "}" ; union_decl ::= { attr_prefix WS? } "union" WS1 ident [ generic_params ] [ WS? where_clause ] WS? "{" WS? field_list? WS? "}" ; form_items ::= form_item { WS? ","? WS? form_item } [ WS? "," ] ; form_item ::= field_item | const_decl | type_alias_decl | proc_decl ; class_items ::= class_item { WS? ","? WS? class_item } [ WS? "," ] ; class_item ::= field_item | const_decl | type_alias_decl | proc_decl ; field_list ::= field_item { WS? "," WS? field_item } [ WS? "," ] ; field_item ::= { attr_prefix WS? } [ visibility WS1 ] ident WS? ":" WS? type_expr [ WS? "=" WS? expr ] ; bits_decl ::= { attr_prefix WS? } "bits" WS1 ident [ WS? ":" WS? type_expr ] WS? "{" WS? bitfield_list? WS? "}" ; bitfield_list ::= bitfield_item { WS? "," WS? bitfield_item } [ WS? "," ] ; bitfield_item ::= ident WS? ":" WS? expr WS? ".." WS? expr ; pick_decl ::= { attr_prefix WS? } "pick" WS1 ident [ generic_params ] [ WS? ":" WS? type_expr ] [ WS? where_clause ] WS? "{" WS? case_list? WS? "}" ; case_list ::= case_item { WS? "," WS? case_item } [ WS? "," ] ; case_item ::= [ "case" WS1 ] ident [ "(" WS? case_payload? WS? ")" ] [ WS? "=" WS? expr ] ; case_payload ::= case_field { WS? "," WS? case_field } [ WS? "," ] ; case_field ::= ident WS? ":" WS? type_expr | type_expr ; flags_decl ::= { attr_prefix WS? } "flags" WS1 ident [ WS? ":" WS? type_expr ] WS? "{" WS? flag_list? WS? "}" ; flag_list ::= flag_item { WS? "," WS? flag_item } [ WS? "," ] ; flag_item ::= ident [ WS? "=" WS? expr ] ; trait_decl ::= { attr_prefix WS? } [ "unsafe", "lang": "en", "section": "docs" }, { "title": "Grammar Diff", "path": "grammar/diff.html", "content": "Grammar Diff Skip to content Grammar Diff (vN vs vN+1) vN vN+1 t 1 <<< ========================================================= t 1 <<< ========================================================= 2    Vitte — Active Frontend Grammar 2    Vitte — Active Frontend Grammar 3    parser-aligned surface for docs/tests/frontend sync 3    parser-aligned surface for docs/tests/frontend sync 4    canonical blocks: { } 4    canonical blocks: { } 5    This file describes the syntax currently preserved by the 5    This file describes the syntax currently preserved by the 6    active frontend AST builder. Ambitious future-only surfaces 6    active frontend AST builder. Ambitious future-only surfaces 7    should not be specified here until they are actually built. 7    should not be specified here until they are actually built. 8    ========================================================= >>> 8    ========================================================= >>> 9 9 10 program ::= WS? { toplevel WS? } EOF ; 10 program ::= WS? { toplevel WS? } EOF ; 11 11 12 <<< ================= Top-level ================= >>> 12 <<< ================= Top-level ================= >>> 13 13 14 toplevel ::= inner_attribute 14 toplevel ::= inner_attribute 15           | space_decl 15           | space_decl 16           | use_decl 16           | use_decl 17           | export_decl 17           | export_decl 18           | const_decl 18           | const_decl 19           | static_decl 19           | static_decl 20           | region_decl 20           | region_decl 21           | type_alias_decl 21           | type_alias_decl 22           | opaque_type_decl 22           | opaque_type_decl 23           | extern_type_decl 23           | extern_type_decl 24           | form_decl 24           | form_decl 25           | class_decl 25           | class_decl 26           | union_decl 26           | union_decl 27           | bits_decl 27           | bits_decl 28           | pick_decl 28           | pick_decl 29           | flags_decl 29           | flags_decl 30           | trait_decl 30           | trait_decl 31           | impl_decl 31           | impl_decl 32           | extern_block 32           | extern_block 33      &n", "lang": "en", "section": "grammar" }, { "title": "Grammar Inventory", "path": "grammar/grammar_inventory.html", "content": "Grammar Inventory Skip to content Grammar Inventory Rule Name Category BINDIGIT other DIGIT other EOF other HEXDIGIT other LETTER other NEWLINE other OCTDIGIT other WS other WS1 other add_expr expression addr_space other alignof_expr expression and_expr expression arg other arg_list other asm_arg other asm_arg_list other asm_stmt statement assert_stmt statement assign_expr expression assign_op other assign_target other associated_type_decl declaration attr_arg other attr_arg_list other attr_path other attr_prefix other await_suffix other backend_decl declaration bench_decl declaration bit_and_expr expression bit_or_expr expression bit_xor_expr expression bitfield_item other bitfield_list other bits_decl declaration block other block_comment other bool_lit other break_stmt statement builtin_expr expression bytes_lit other call_suffix other callconv other capability other capability_list other case_field other case_item other case_list other case_payload other cast_expr expression char_char other char_lit other class_decl declaration class_item other class_items other coalesce_expr expression compiler_decl declaration const_decl declaration continue_stmt statement critical_stmt statement defer_stmt statement diagnostic_decl declaration doc_comment other docstring other dyn_type other effects_clause other emit_stmt statement entry_decl declaration eq_expr expression escape_seq other exponent other export_decl declaration expr expression expr_stmt statement extern_abi other extern_block other extern_clause other extern_item other extern_proc_decl declaration extern_type_decl declaration field_init other field_init_list other field_item other field_list other fixed_array_type other flag_item other flag_list other flags_decl declaration float_lit other for_stmt statement form_decl declaration form_item other form_items other generic_param other generic_param_list other generic_params other give_stmt statement ident other ident_list other ident_or_string other if_expr expression if_stmt statement impl_decl declaration impl_head other impl_item other impl_trait_type other import_item other import_items other index_expr expression index_suffix other inner_attribute other int_lit other intrinsic_decl declaration lambda_expr expression let_stmt statement lifetime other line_comment other list_comp other list_lit other literal other local_const_stmt statement loop_stmt statement macro_decl declaration macro_kind other macro_param other macro_param_list other map_item other map_items other map_lit other match_arm_body other match_expr expression match_stmt statement member_suffix other meta_arg other meta_arg_list other meta_args other meta_tail other module_path other mul_expr expression nameof_expr expression normal_param other null_lit other offsetof_expr expression opaque_type_decl declaration operator_symbol other optional_type other or_expr expression outer_attribute other package_parts other package_path other panic_stmt statement param other param_list other param_mode other pass_decl declaration path_expr expression pattern other pattern_args other pattern_atom other pattern_bind other pattern_ctor other pattern_field other pattern_fields other pattern_head other pattern_list other pattern_or other pattern_range other pattern_struct other pattern_tuple other pick_decl declaration pointer_type other postfix_expr expression primary other primitive_type other proc_decl declaration proc_expr expression proc_modifier other proc_name other proc_signature other proc_suffix other proc_type other program other query_body other query_decl declaration range_expr expression raw_string_char other raw_string_lit other reference_type other region_capabilities other region_decl declaration region_kind other rel_expr expression rel_op other relative other requires_clause other resource_item other resource_items other resource_lit other select_stmt statement self_param other set_lit other set_stmt statement shift_expr expression sizeof_expr expression slice_expr expression slice_type other space_decl declaration static_assert_decl declaration static_decl declaration stmt other stmt_end other string_char other string_lit other struct_lit other suffix other ternary_expr expression test_decl declaration toplevel other trait_bound other trait_decl declaration trait_item other try_stmt statement try_suffix other tuple_lit other tuple_type other type_alias_decl declaration type_atom other type_expr expression type_list other type_param other type_path other type_prefix other type_primary other type_qual other type_qualifier other type_union other typeof_expr expression unary_expr expression union_decl declaration unreachable_stmt statement unsafe_expr expression unsafe_stmt statement use_decl declaration use_glob other use_group other variadic_param other visibility other visibility_scope other when_match_stmt statement where_bound other where_bounds other where_clause other while_stmt statement with_stmt statement zone_comment other", "lang": "en", "section": "grammar" }, { "title": "Vitte Grammar Practical Guide", "path": "grammar/index.html", "content": "Vitte Grammar Practical Guide Skip to content Vitte Grammar Practical Guide Practical usage guide generated from src/vitte/grammar/vitte.ebnf . Reading Paths Beginner Start with space_decl , use_decl , const_decl , proc_decl . Write tiny files with one declaration at a time. Validate syntax before mixing advanced constructs. Intermediate Study type_alias_decl , form_decl , class_decl , impl_decl . Practice generics and where-clauses. Check expression and statement combinations. Expert Focus on compiler surface: compiler_decl , query_decl , backend_decl . Use grammar as strict contract for tooling and tests. Track parser behavior against edge cases per production. Rule Validation Table Rule Valid Example Invalid Example Expected Diagnostic space_decl space vitte/compiler/entry space Missing module path after `space`. use_decl use vitte/io use Import path missing after `use`. proc_decl proc main() -> int { give 0 } proc main( -> int { give 0 } Malformed parameter list or signature. const_decl const VERSION: string = "1.0" const = "1.0" Const identifier is required. entry_decl entry app at vitte/bootstrap { } entry app vitte/bootstrap { } Missing `at` in entry declaration. expr a + b * c a + * c Unexpected operator placement in expression. Rule Anchors Index program toplevel space_decl use_decl use_glob use_group import_items import_item export_decl const_decl static_decl region_decl region_kind region_capabilities type_alias_decl opaque_type_decl extern_type_decl form_decl class_decl union_decl form_items form_item class_items class_item field_list field_item bits_decl bitfield_list bitfield_item pick_decl case_list case_item case_payload case_field flags_decl flag_list flag_item trait_decl trait_item associated_type_decl impl_decl impl_head impl_item proc_signature proc_decl proc_name operator_symbol proc_modifier proc_suffix extern_block extern_item extern_proc_decl extern_clause extern_abi callconv intrinsic_decl macro_decl macro_param_list macro_param macro_kind static_assert_decl test_decl bench_decl entry_decl visibility visibility_scope generic_params generic_param_list generic_param where_clause where_bounds where_bound trait_bound param_list param self_param normal_param variadic_param param_mode effects_clause requires_clause capability_list capability module_path package_path relative package_parts ident_list query_decl query_body compiler_decl pass_decl backend_decl diagnostic_decl ident_or_string meta_args meta_arg_list meta_arg meta_tail attr_prefix inner_attribute outer_attribute doc_comment docstring attr_path attr_arg_list attr_arg block stmt stmt_end local_const_stmt let_stmt set_stmt assign_target give_stmt try_stmt defer_stmt asm_stmt asm_arg_list asm_arg Full EBNF (Anchored) <<< ========================================================= Vitte — Active Frontend Grammar parser-aligned surface for docs/tests/frontend sync canonical blocks: { } This file describes the syntax currently preserved by the active frontend AST builder. Ambitious future-only surfaces should not be specified here until they are actually built. ========================================================= >>> program ::= WS? { toplevel WS? } EOF ; <<< ================= Top-level ================= >>> toplevel ::= inner_attribute | space_decl | use_decl | export_decl | const_decl | static_decl | region_decl | type_alias_decl | opaque_type_decl | extern_type_decl | form_decl | class_decl | union_decl | bits_decl | pick_decl | flags_decl | trait_decl | impl_decl | extern_block | proc_decl | intrinsic_decl | compiler_decl | query_decl | pass_decl | backend_decl | diagnostic_decl | macro_decl | static_assert_decl | test_decl | bench_decl | entry_decl ; space_decl ::= "space" WS1 module_path ; use_decl ::= "use" WS1 package_path [ use_group | use_glob ] [ WS1 "as" WS1 ident ] ; use_glob ::= "." "*" ; use_group ::= "." "{" WS? ( "*" | import_items [ WS? "," WS? "*" ]? ) WS? "}" ; import_items ::= import_item { WS? "," WS? import_item } [ WS? "," ] ; import_item ::= ident [ WS1 "as" WS1 ident ] ; export_decl ::= "export" WS1 ( "*" | ident_list | "{" WS? ident_list WS? "}" ) ; const_decl ::= { attr_prefix WS? } "const" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ; static_decl ::= { attr_prefix WS? } "static" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ; region_decl ::= { attr_prefix WS? } "region" WS1 ident [ WS? ":" WS? region_kind ] [ WS? region_capabilities ] WS? meta_tail ; region_kind ::= "stack" | "heap" | "arena" | "static" | "mmio" | "dma" | ident ; region_capabilities ::= "(" WS? ident_list? WS? ")" ; type_alia", "lang": "en", "section": "grammar" }, { "title": "AST/HIR/MIR Pipeline Overview", "path": "grammar/pipeline.html", "content": "AST/HIR/MIR Pipeline Overview Skip to content AST/HIR/MIR Pipeline Overview Lexer Parser AST HIR Semantic Analysis Type Checking Borrow Checking MIR Backend Lexer The lexer tokenizes the source code into a stream of tokens, which are the basic units of syntax. Parser The parser processes tokens according to grammar rules to produce an abstract syntax tree (AST). AST The Abstract Syntax Tree represents the syntactic structure of the source code in a tree form. HIR The High-level Intermediate Representation (HIR) is a semantic representation derived from the AST. Semantic Analysis This phase analyzes the HIR to check for semantic correctness like scope and type usage. Type Checking Type checking ensures that operations in the code are performed on compatible types. Borrow Checking Borrow checking enforces rules about ownership and lifetimes of references. MIR The Mid-level Intermediate Representation (MIR) is a lowered form of HIR optimized for analysis and transformation. Backend The backend generates executable code or other output formats from the MIR.", "lang": "en", "section": "grammar" }, { "title": "Grammar Pocket", "path": "grammar/pocket.html", "content": "Grammar Pocket Skip to content Grammar Pocket Reference Checksum: 4ab4e767d61092f8b4f0c031e617d8ddaccf9515fbf6ba702a107b2bca58b7f2 program ::= WS? { toplevel WS? } EOF ; toplevel ::= inner_attribute space_decl ::= "space" WS1 module_path ; use_decl ::= "use" WS1 package_path [ use_group | use_glob ] [ WS1 "as" WS1 ident ] ; use_glob ::= "." "*" ; use_group ::= "." "{" WS? ( "*" | import_items [ WS? "," WS? "*" ]? ) WS? "}" ; import_items ::= import_item { WS? "," WS? import_item } [ WS? "," ] ; import_item ::= ident [ WS1 "as" WS1 ident ] ; export_decl ::= "export" WS1 ( "*" | ident_list | "{" WS? ident_list WS? "}" ) ; const_decl ::= { attr_prefix WS? } "const" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ; static_decl ::= { attr_prefix WS? } "static" WS1 ident [ WS? ":" WS? type_expr ] WS? "=" WS? expr ; region_decl ::= { attr_prefix WS? } "region" WS1 ident [ WS? ":" WS? region_kind ] [ WS? region_capabilities ] WS? meta_tail ; region_kind ::= "stack" | "heap" | "arena" | "static" | "mmio" | "dma" | ident ; region_capabilities ::= "(" WS? ident_list? WS? ")" ; type_alias_decl ::= { attr_prefix WS? } "type" WS1 ident [ generic_params ] WS? "=" WS? type_expr ; opaque_type_decl ::= { attr_prefix WS? } "opaque" WS1 "type" WS1 ident [ generic_params ] [ WS? "=" WS? type_expr ] ; extern_type_decl ::= { attr_prefix WS? } "extern" WS1 "type" WS1 ident [ generic_params ] [ WS? ";" ] ; form_decl ::= { attr_prefix WS? } "form" WS1 ident [ generic_params ] [ WS? where_clause ] WS? "{" WS? form_items? WS? "}" ; class_decl ::= { attr_prefix WS? } "class" WS1 ident [ generic_params ] [ WS? where_clause ] WS? "{" WS? class_items? WS? "}" ; union_decl ::= { attr_prefix WS? } "union" WS1 ident [ generic_params ] [ WS? where_clause ] WS? "{" WS? field_list? WS? "}" ; form_items ::= form_item { WS? ","? WS? form_item } [ WS? "," ] ; form_item ::= field_item | const_decl | type_alias_decl | proc_decl ; class_items ::= class_item { WS? ","? WS? class_item } [ WS? "," ] ; class_item ::= field_item | const_decl | type_alias_decl | proc_decl ; field_list ::= field_item { WS? "," WS? field_item } [ WS? "," ] ; field_item ::= { attr_prefix WS? } [ visibility WS1 ] ident WS? ":" WS? type_expr [ WS? "=" WS? expr ] ; bits_decl ::= { attr_prefix WS? } "bits" WS1 ident [ WS? ":" WS? type_expr ] WS? "{" WS? bitfield_list? WS? "}" ; bitfield_list ::= bitfield_item { WS? "," WS? bitfield_item } [ WS? "," ] ; bitfield_item ::= ident WS? ":" WS? expr WS? ".." WS? expr ; pick_decl ::= { attr_prefix WS? } "pick" WS1 ident [ generic_params ] [ WS? ":" WS? type_expr ] [ WS? where_clause ] WS? "{" WS? case_list? WS? "}" ; case_list ::= case_item { WS? "," WS? case_item } [ WS? "," ] ; case_item ::= [ "case" WS1 ] ident [ "(" WS? case_payload? WS? ")" ] [ WS? "=" WS? expr ] ; case_payload ::= case_field { WS? "," WS? case_field } [ WS? "," ] ; case_field ::= ident WS? ":" WS? type_expr | type_expr ; flags_decl ::= { attr_prefix WS? } "flags" WS1 ident [ WS? ":" WS? type_expr ] WS? "{" WS? flag_list? WS? "}" ; flag_list ::= flag_item { WS? "," WS? flag_item } [ WS? "," ] ; flag_item ::= ident [ WS? "=" WS? expr ] ; trait_decl ::= { attr_prefix WS? } [ "unsafe" WS1 ] "trait" WS1 ident [ generic_params ] [ WS? where_clause ] WS? "{" WS? trait_item* WS? "}" ; trait_item ::= proc_signature | const_decl | associated_type_decl ; associated_type_decl ::= "type" WS1 ident [ WS? ":" WS? trait_bound ] [ WS? "=" WS? type_expr ] ; impl_decl ::= { attr_prefix WS? } [ "unsafe" WS1 ] "impl" WS1 impl_head [ WS? where_clause ] WS? "{" WS? impl_item* WS? "}" ; impl_head ::= type_expr | type_expr WS1 "for" WS1 type_expr ; impl_item ::= const_decl | type_alias_decl | associated_type_decl | proc_decl ; proc_signature ::= { attr_prefix WS? } "proc" WS1 ident [ generic_params ] proc_decl ::= { attr_prefix WS? } [ visibility WS1 ] proc_modifier* [ extern_clause WS1 ] "proc" WS1 proc_name [ generic_params ] proc_name ::= ident | "operator" WS? operator_symbol ; op", "lang": "en", "section": "grammar" }, { "title": "Priorité de grammaire", "path": "grammar/precedence.html", "content": "Priorité de grammaire Skip to content Vitte Welcome Documentation Download Source Community News Diagnostics Suggestions Grammar Priority Compatibility point for operator precedence. grammar/precedence.html Back to home", "lang": "en", "section": "grammar" }, { "title": "Railroad Diagram Index", "path": "grammar/railroad_index.html", "content": "Railroad Diagram Index Skip to content Railroad Diagram Index Rule Status space_decl available use_decl available from_decl missing const_decl available form_decl available class_decl available pick_decl available proc_decl available entry_decl available macro_decl available stmt available expr available type_expr available match_expr available select_stmt available if_stmt available while_stmt available for_stmt available", "lang": "en", "section": "grammar" }, { "title": "Grammar Search Index", "path": "grammar/search.html", "content": "Grammar Search Index Skip to content Grammar Search Index A B C D E F G H I L M N O P Q R S T U V W Z A add_expr addr_space alignof_expr and_expr arg arg_list asm_arg asm_arg_list asm_stmt assert_stmt assign_expr assign_op assign_target associated_type_decl attr_arg attr_arg_list attr_path attr_prefix await_suffix B BINDIGIT backend_decl bench_decl bit_and_expr bit_or_expr bit_xor_expr bitfield_item bitfield_list bits_decl block block_comment bool_lit break_stmt builtin_expr bytes_lit C call_suffix callconv capability capability_list case_field case_item case_list case_payload cast_expr char_char char_lit class_decl class_item class_items coalesce_expr compiler_decl const_decl continue_stmt critical_stmt D DIGIT defer_stmt diagnostic_decl doc_comment docstring dyn_type E EOF effects_clause emit_stmt entry_decl eq_expr escape_seq exponent export_decl expr expr_stmt extern_abi extern_block extern_clause extern_item extern_proc_decl extern_type_decl F field_init field_init_list field_item field_list fixed_array_type flag_item flag_list flags_decl float_lit for_stmt form_decl form_item form_items G generic_param generic_param_list generic_params give_stmt H HEXDIGIT I ident ident_list ident_or_string if_expr if_stmt impl_decl impl_head impl_item impl_trait_type import_item import_items index_expr index_suffix inner_attribute int_lit intrinsic_decl L LETTER lambda_expr let_stmt lifetime line_comment list_comp list_lit literal local_const_stmt loop_stmt M macro_decl macro_kind macro_param macro_param_list map_item map_items map_lit match_arm_body match_expr match_stmt member_suffix meta_arg meta_arg_list meta_args meta_tail module_path mul_expr N NEWLINE nameof_expr normal_param null_lit O OCTDIGIT offsetof_expr opaque_type_decl operator_symbol optional_type or_expr outer_attribute P package_parts package_path panic_stmt param param_list param_mode pass_decl path_expr pattern pattern_args pattern_atom pattern_bind pattern_ctor pattern_field pattern_fields pattern_head pattern_list pattern_or pattern_range pattern_struct pattern_tuple pick_decl pointer_type postfix_expr primary primitive_type proc_decl proc_expr proc_modifier proc_name proc_signature proc_suffix proc_type program Q query_body query_decl R range_expr raw_string_char raw_string_lit reference_type region_capabilities region_decl region_kind rel_expr rel_op relative requires_clause resource_item resource_items resource_lit S select_stmt self_param set_lit set_stmt shift_expr sizeof_expr slice_expr slice_type space_decl static_assert_decl static_decl stmt stmt_end string_char string_lit struct_lit suffix T ternary_expr test_decl toplevel trait_bound trait_decl trait_item try_stmt try_suffix tuple_lit tuple_type type_alias_decl type_atom type_expr type_list type_param type_path type_prefix type_primary type_qual type_qualifier type_union typeof_expr U unary_expr union_decl unreachable_stmt unsafe_expr unsafe_stmt use_decl use_glob use_group V variadic_param visibility visibility_scope W WS WS1 when_match_stmt where_bound where_bounds where_clause while_stmt with_stmt Z zone_comment", "lang": "en", "section": "grammar" }, { "title": "Grammar Statistics", "path": "grammar/statistics.html", "content": "Grammar Statistics Skip to content Grammar Statistics Statistic Value Total Rules 256 Grammar Lines 626 Grammar Size (bytes) 23721 Average Rule Density 0.4089 Declaration Rules 31 Statement Rules 24 Expression Rules 33 Checksum 4ab4e767d61092f8b4f0c031e617d8ddaccf9515fbf6ba702a107b2bca58b7f2 Build Timestamp (UTC) 2026-07-18T06:21:22.704233+00:00 Keyword Frequency Keyword Count class 3 const 2 entry 1 for 4 form 3 from 0 if 6 macro 4 match 4 pick 1 proc 8 return 0 select 1 space 2 use 7 while 1", "lang": "en", "section": "grammar" }, { "title": "Grammar Status", "path": "grammar/status.html", "content": "Grammar Status Skip to content Grammar Status { "checksum": "4ab4e767d61092f8b4f0c031e617d8ddaccf9515fbf6ba702a107b2bca58b7f2", "built_at_utc": "2026-07-18T06:21:22.819225+00:00", "rules_count": 256, "coverage_percent": 0.0, "parser_compat": "aligned to src/vitte/grammar/vitte.ebnf" }", "lang": "en", "section": "grammar" }, { "title": "Grammar Toolbox", "path": "grammar/toolbox.html", "content": "Grammar Toolbox Skip to content Grammar Toolbox Coverage: 0.00% (0/256) Frequent Errors mapped to Diagnostics Error Rule Expected Diagnostic Missing module path after space space_decl top-level parse error: expected module path Malformed proc signature proc_decl signature parse error: expected ) or parameter Missing const identifier const_decl declaration parse error: expected identifier Missing at in entry declaration entry_decl entry parse error: expected keyword at Operator placement invalid expr expression parse error: unexpected operator token Syntax Constructor Matrix declaration space_decl , use_decl , export_decl , const_decl , static_decl , region_decl , type_alias_decl , opaque_type_decl , extern_type_decl , form_decl , class_decl , union_decl , bits_decl , pick_decl , flags_decl , trait_decl , associated_type_decl , impl_decl , proc_decl , extern_proc_decl , intrinsic_decl , macro_decl , static_assert_decl , test_decl , bench_decl , entry_decl , query_decl , compiler_decl , pass_decl , backend_decl , diagnostic_decl statement stmt , local_const_stmt , let_stmt , set_stmt , give_stmt , try_stmt , defer_stmt , asm_stmt , unsafe_stmt , emit_stmt , assert_stmt , panic_stmt , unreachable_stmt , if_stmt , while_stmt , loop_stmt , for_stmt , break_stmt , continue_stmt , select_stmt , match_stmt , when_match_stmt , with_stmt , critical_stmt , expr_stmt expression expr , assign_expr , ternary_expr , coalesce_expr , range_expr , or_expr , and_expr , bit_or_expr , bit_xor_expr , bit_and_expr , eq_expr , rel_expr , shift_expr , add_expr , mul_expr , cast_expr , unary_expr , postfix_expr , index_expr , slice_expr , path_expr , if_expr , proc_expr , match_expr , lambda_expr , unsafe_expr , builtin_expr , sizeof_expr , alignof_expr , offsetof_expr , typeof_expr , nameof_expr , type_expr By Keyword proc proc_signature , proc_decl , proc_name , proc_modifier , proc_suffix , extern_proc_decl , proc_expr , proc_type form form_decl , form_items , form_item pick pick_decl macro macro_decl , macro_param_list , macro_param , macro_kind trait trait_decl , trait_item , trait_bound , impl_trait_type impl impl_decl , impl_head , impl_item , impl_trait_type entry entry_decl query query_decl , query_body backend backend_decl compiler compiler_decl Rule to Tests Traceability Rule Tests program none toplevel none space_decl none use_decl none use_glob none use_group none import_items none import_item none export_decl none const_decl none static_decl none region_decl none region_kind none region_capabilities none type_alias_decl none opaque_type_decl none extern_type_decl none form_decl none class_decl none union_decl none form_items none form_item none class_items none class_item none field_list none field_item none bits_decl none bitfield_list none bitfield_item none pick_decl none case_list none case_item none case_payload none case_field none flags_decl none flag_list none flag_item none trait_decl none trait_item none associated_type_decl none impl_decl none impl_head none impl_item none proc_signature none proc_decl none proc_name none operator_symbol none proc_modifier none proc_suffix none extern_block none extern_item none extern_proc_decl none extern_clause none extern_abi none callconv none intrinsic_decl none macro_decl none macro_param_list none macro_param none macro_kind none static_assert_decl none test_decl none bench_decl none entry_decl none visibility none visibility_scope none generic_params none generic_param_list none generic_param none where_clause none where_bounds none where_bound none trait_bound none param_list none param none self_param none normal_param none variadic_param none param_mode none effects_clause none requires_clause none capability_list none capability none module_path none package_path none relative none package_parts none ident_list none query_decl none query_body none compiler_decl none pass_decl none backend_decl none diagnostic_decl none ident_or_string none meta_args none meta_arg_list none meta_arg none meta_tail none attr_prefix none inner_attribute none outer_attribute none doc_comment none docstring none attr_path none attr_arg_list none attr_arg none block none stmt none stmt_end none local_const_stmt none let_stmt none set_stmt none assign_target none give_stmt none try_stmt none defer_stmt none asm_stmt none asm_arg_list none asm_arg none unsafe_stmt none emit_stmt none assert_stmt none panic_stmt none unreachable_stmt none if_stmt none while_stmt none loop_stmt none for_stmt none break_stmt none continue_stmt none select_stmt none match_stmt none match_arm_body none when_match_stmt none with_stmt none critical_stmt none expr_stmt none expr none assign_expr none assign_op none ternary_expr none coalesce_expr none range_expr none or_expr none and_expr none bit_or_expr none bit_xor_expr none bit_and_expr none eq_expr none rel_expr none rel_op none shift_expr none add_expr none mul_expr none cast_expr none unary_expr none postfix_expr none call_suffix none member_suffix none ", "lang": "en", "section": "grammar" }, { "title": "STYLE", "path": "book/STYLE.html", "content": "STYLE Skip to content Vitte Welcome Documentation Download Source Community News Diagnostics Suggestions Editorial Style Guide (Vitte Book) Book Summary Checklist Glossary This guide is the editorial contract for the whole book. Its purpose is simple: every chapter must teach one coherent thing with one coherent example, without repetitive filler and without line-by-line paraphrase. Core Rules One chapter, one main problem, one main example. Explain the whole flow before explaining local syntax. Do not write line-by-line commentary unless the chapter is explicitly about parsing or debugging a single statement. Every technical chapter must include a nominal path, an invalid path, and an observable result. Every keyword page must show the keyword in Vitte and compare it briefly to C when that comparison clarifies intent. Chapter Contract Concrete Problem : name the real engineering problem. Red Thread (Single Project) : keep one scenario from start to finish. For what : say what this chapter helps the reader build, debug, or decide. What you are going to do : explain the proof path of the chapter. Coherent example : one complete program or subsystem extract. Global explanation : explain responsibilities, data flow, boundaries, and failure points. Invalid case : show how the chapter fails and how the reader notices it. Short exercise : ask for one modification that preserves the chapter invariant. Keyword Contract Definition : state what the keyword means in the language. Syntax : show the canonical shape. Example in Vitte : complete, runnable or near-runnable snippet. Example in C : short comparison when it clarifies semantics. Invalid example : show the misuse and the expected family of diagnosis. Global explanation : explain what the keyword changes in the full flow. Anti-Repetition Rules Do not repeat generic filler such as “read the core idea first”. Do not duplicate the same pitfall list across unrelated chapters. Do not rename the same section three ways; keep one stable heading. Do not comment each line if the reader really needs the architecture of the block. Stdlib Policy The stdlib must be documented by family, not by isolated minimal snippets only. Each family must explain its responsibility, main submodules, integration boundaries, and realistic usage. Examples should be complete enough to show where data enters, which library layer acts, and what comes out. Length And Density Prefer dense examples over decorative prose. Keep bullets for inventories and contracts, not for replacing explanation. If a chapter grows, add more evidence and scenarios, not more filler. Paths And Links Reference the book with the docs/book/ prefix when discussing repository paths. Prefer stable repository-relative paths and stable chapter numbering. book/STYLE.html Back to home", "lang": "en", "section": "book" }, { "title": "Book Health Report", "path": "book/book-health.html", "content": "Book Health Report table { border-collapse: collapse; width: 100%; } th, td { border: 1px solid #ccc; padding: 8px; text-align: left; } th { cursor: pointer; background-color: #f2f2f2; } Book Health Report Average Score: 0.0 / 100 Total Chapters: 0 Title Score Examples FAQ Tables", "lang": "en", "section": "book" }, { "title": "Editorial Proofreading Checklist", "path": "book/checklist.html", "content": "Editorial Proofreading Checklist Skip to content Vitte Welcome Documentation Download Source Community News Diagnostics Suggestions Editorial Proofreading Checklist Book Summary Style Glossary Use this list before validating a chapter. Vocabulary consistency: the same concepts have the same names. Punctuation: neatly finished sentences and lists. Numerical examples: at least one limiting case and one nominal case. Invariants: security/validity rules are explicit. Readability: Each block of code has a clear intent. Quick check: the chapter answers \"what happens if the input is invalid?\". Exercise: a À faire is present with a minimal answer key. book/checklist.html Back to home", "lang": "en", "section": "book" }, { "title": "CI rapide (local)", "path": "book/ci.html", "content": "CI rapide (local) Skip to content Vitte Welcome Documentation Download Source Community News Diagnostics Suggestions Fast CI (local) This project uses make ci-strict as a local full pass: grammar alignment ( grammar-check ), Strict QA docs ( book-qa-strict ), lint stdlib conventions ( package-layout-lint ), lint imports legacy ( legacy-import-path-lint ), negative tests ( negative-tests ), diagnostic snapshots ( diag-snapshots ). One-line order OPENSSL_DIR=/opt/homebrew/opt/openssl@3 CURL_DIR=/opt/homebrew/opt/curl make ci-strict Variant with session export export OPENSSL_DIR=/opt/homebrew/opt/openssl@3 export CURL_DIR=/opt/homebrew/opt/curl make ci-strict Quick dependency check test -d /opt/homebrew/opt/openssl@3 && echo "openssl ok" test -d /opt/homebrew/opt/curl && echo "curl ok" book/ci.html Back to home", "lang": "en", "section": "book" }, { "title": "Classic mistakes", "path": "book/classic-mistakes.html", "content": "Classic mistakes Skip to content Vitte Welcome Documentation Download Source Community News Diagnostics Suggestions Classic mistakes This page centralizes recurring errors observed in the chapters. Forgetting a guard before a risky operation. Mix business logic and technical projection. Leave implicit states unmodeled. Duplicate a rule instead of centralizing it. Optimize before you have locked in the expected behavior. Recommended use: before validating a chapter, check this list alongside the editorial checklist. book/classic-mistakes.html Back to home", "lang": "en", "section": "book" }, { "title": "CLI Vitte", "path": "book/cli.html", "content": "CLI Vitte Skip to content Vitte Welcome Documentation Download Source Community News Diagnostics Suggestions CLI Vitte Use : vitte [command] [options] <input> Commands (recommended): help Show help and common tasks init [dir] Create a minimal project skeleton explain <code> Explain a diagnosis (e.g. E0001 ) doctor Check toolchain prerequisites parse Parser only (without backend) check Parse + resolve + IR (without backend) emit Only emit Vitte (without compilation) build Complete build (default) profile Complete construction with summary of times/memory per step reduce Reduce a failed file to a minimal reproducer clean-cache Delete stage cache files .vitte-cache mod graph Display the import graph, cycles and module weights (LOC/exports/imports) mod doctor Check the hygiene of imports (unused, aliases, canonical paths, collisions) mod contract-diff Compare the exported contract of a module between 2 entries ( --old / --new ) Options: --lang <code> Language of diagnostics (e.g. en , fr ). By default LANG/LC_ALL , then en . --explain <code> Explain a diagnosis (e.g. E0001 ). --stage <name> Stop at parse|resolve|ir|backend . --diag-json Issue diagnostics in JSON. --diag-json-pretty Issue readable JSON diagnostics (includes diag_schema ). --diag-code-only Issue compact diagnostics ( file:line:col CODE ), useful for CI. --deterministic Stable output order for diagnostics and tools. --cache-report Show cache hit/miss ratio parse/resolve/ir. --runtime-profile <name> Restrict runtime/stdlib imports: core|system|desktop|arduino . --allow-experimental Allow imports from modules experimental/... . --warn-experimental Degrade an experimental import refusal to a warning (migration mode). --deny-internal Enforce confidentiality of internal modules (default behavior). --allow-internal Disable internal module privacy checking. --strict-modules Prohibit glob imports and impose a strict form of module imports. --dump-stdlib-map Show resolved map stdlib module -> exported symbols (history option name). --dump-module-index Export the full JSON of the module index ( modules , imports , exports , loc ). --json For mod graph : emit the JSON payload of the graph. --from <module> For mod graph : limit the view to the subgraph reachable from the module. --dump-ast Export the AST after parsing. --dump-ir Export IR ( --dump-mir as alias). --strict-types Reject compatibility aliases ( integer , uint32 , etc.) and enforce canonical names. --strict-imports Require explicit import aliases, reject unused aliases, and disallow relative paths. --fix For mod doctor : Show concrete rewrite suggestions. --max-imports <N> For mod doctor : report modules whose fan-out exceeds N . --old <file> / --new <file> For mod contract-diff . --strict-bridge Alias ​​of --strict-imports for the binding policy. --fail-on-warning Treat warnings as errors. --stdout Output Vitte to standard output (implies emit ). --emit-vitte Emit a Vitte artifact only. --repro Enable reproducible output. --repro-strict Impose a strictly deterministic order for IR lowering. --parse-modules Parse + load modules (without resolution/lowering). --parse-silent Delete parse-only mode information logs. Diagnostics include stable error codes (e.g. error[E0001]: ... ). Examples: vitte help vitte init vitte init app vitte explain E0001 vitte doctor vitte parse --lang=fr src/main.vit Error codes: Diagnostics use stable prefixes per layer: E000x : parse/grammar E100x : resolution E1007 : invalid signed/unsigned cast E1010..E1020 : module/stdlib import contract E200x : IR/lowering E300x : backend/toolchain Codes are defined in src/compiler/frontend/diagnostics_messages.vitl . .ftl localization files can translate by code (preferred) or by message key. Stdlib: See docs/book/stdlib.html for stdlib modules and examples. Contract and ABI surface: docs/book/compiler-stdlib-contract.html , docs/book/stdlib_abi_surface_v1.txt . Historical options (still supported): mod api-diff (aka mod contract-diff ) --stdlib-profile (historical alias of --runtime-profile ) correspondence: minimal->core , kernel->system , full->desktop --parse-only --resolve-only --hir-only --mir-only --emit-vitte --strict-parse Notes: The commands set a default mode, but explicit options take precedence. For strict analysis, use parse --strict-parse <file> . For the JSON of the graph in CI: vitte mod graph --json --from __root__ <file> . book/cli.html Back to home", "lang": "en", "section": "book" }, { "title": "Compiler Contract <-> Stdlib", "path": "book/compiler-stdlib-contract.html", "content": "Compiler Contract <-> Stdlib Skip to content Vitte Welcome Documentation Download Source Community News Diagnostics Suggestions Compiler contract stdlib This document defines the stable contract between the Vitte compiler and the stdlib runtime surface. Terminology used in the doc and CLI: “Vitte binding surface” replaces “libc surface”. “Vitte binding” replaces “interop C”. 1. Source of truth Versioned ABI surface file: stdlib_abi_surface_v1.txt (historical name). Next ABI version: stdlib_abi_surface_v2.txt (historical name). Source root of the stdlib: dedicated source tree. Runtime ABI header: src/compiler/backends/runtime/vitte_runtime.vitl . 2. Stable stdlib profiles --runtime-profile controls which stdlib modules are allowed. --stdlib-profile is kept as a historical alias. core (history minimal ): only core/** . desktop (history full ): all stdlib modules. system (history kernel ): core/** + kernel/** . arduino : core/** + arduino/** . If an import is not authorized, the compiler emits E1010 . If a stdlib module is missing, the compiler emits E1014 . Module levels: public : stable import surface. internal : private namespace ( */internal/* ), blocked without owner ( E1016 ). experimental : activation only with --allow-experimental ( E1015 ). 3. Strictness of imports --strict-imports (aka --strict-bridge ) imposes import hygiene: explicit alias required on use / pull ( E1011 ). explicit aliases must be used ( E1012 ). non-canonical relative paths are rejected ( E1013 ). 4. Runtime/Vitte link error boundary Parse layer: E000x . Resolve layer: E100x (includes stdlib/import constraints). IR layer: E200x . Backend layer/toolchain: E300x . 5. Tools Export stdlib symbol map: vitte check --dump-stdlib-map <file.vit> Export the full module index: vitte check --dump-module-index <file.vit> Graph and doctor: vitte mod graph <file.vit> vitte mod doctor <file.vit> Check surface ABI against stdlib source: tools/lint_stdlib_api.py ABI compatibility issue: tools/check_stdlib_abi_compat.py Profile Snapshots: tools/stdlib_profile_snapshots.sh 6. Binding surface name For documentation and examples of system/Vitte binding, prefer stdlib-oriented names: print read path env bytes alloc process Bridge module plan in the doc: bridge/io bridge/memory bridge/system bridge/time bridge/net book/compiler-stdlib-contract.html Back to home", "lang": "en", "section": "book" }, { "title": "Vitte Errors", "path": "book/errors.html", "content": "Vitte Errors Skip to content Vitte Welcome Documentation Download Source Community News Diagnostics Suggestions Vitte Errors This page is the stable reference for common diagnostics and fixes. Layer map: parse : syntax and structure checks. resolve : name, type, import and declaration checks. IR : lowering and intermediate representation checks. backend : Code generation and toolchain checks. Each diagnosis follows the same structure: Code Symptom Probable cause Correction Example See also ## E0001 - expected identifier Code: E0001 Layer: parse Symptom: The parser was expecting a variable, type, module, or declaration name. Probable cause: a declaration is missing its identifier, or the token after a keyword is not a valid name. Fix: Add a valid identifier where the parser indicates. Example: proc main() -> i32 { return 0 } See also: book/poche/07-reading-errors.html , book/cli.html ## E0002 - expected expression Code: E0002 Layer: parse Symptom: The parser was expecting an expression at this location. Probable cause: A value, call, or block expression is missing after a keyword or operator. Fix: provide an expression like 1 , name , call() or { ... } . Example: let x = 1 See also: book/poche/07-reading-errors.html , book/cli.html ## E0003 - expected pattern Code: E0003 Layer: parse Symptom: The parser was expecting a pattern. Probable cause: A construct when or similar to match received an incomplete pattern. Fix: use a pattern as an identifier or constructor, for example Some(x) . Example: when x is Option.Some { return 0 } See also: book/poche/07-reading-errors.html , book/cli.html ## E0004 - expected type Code: E0004 Layer: parse Symptom: The parser was expecting a type name. Probable cause: A type annotation is present, but the right member is missing or malformed. Fix: Use a built-in type or a named type, for example int or Option[T] . Example: proc id(x: int) -> int { return x } See also: book/poche/07-reading-errors.html , book/cli.html ## E0005 - `end` expected Code: E0005 Layer: parse Symptom: A block was opened but not closed with end or .end . Probable cause: a proc , form or pick block is missing its terminator. Fix: Add missing terminator for open construct. Example: form Point field x as int .end See also: book/poche/07-reading-errors.html , book/cli.html ## E0006 - `proc` expected after attribute Code: E0006 Layer: parse Symptom: An attribute must be followed by an proc declaration. Probable cause: the attribute is hooked to the wrong element or is alone. Fix: Place the attribute directly above a proc . Example: #[inline] proc add(a: int, b: int) -> int { return a + b } See also: book/poche/07-reading-errors.html , book/cli.html ## E0007 - top-level declaration expected Code: E0007 Layer: parse Symptom: The parser was expecting a top-level declaration. Probable cause: An element appears at the root of the file, but it is not one of the supported declarations. Correction: limit the top-level to space , use , form , pick , type , const , proc and entry . Example: space my/app proc main() -> int { return 0 } See also: book/poche/07-reading-errors.html , book/cli.html ## E0008 - duplicate pattern binding Code: E0008 Layer: parse Symptom: A pattern has linked the same name more than once. Probable cause: The pattern reuses a binding in two places. Fix: give a separate name to each binding. Example: when Pair(x, x) { return 0 } See also: book/poche/07-reading-errors.html , book/cli.html ## E0009 - unknown type Code: E0009 Layer: resolve Symptom: A referenced type name was not found. Probable cause: Type is misspelled or not imported. Fix: check spelling or import type with use or pull . Example: use std/core/option.Option proc f(x: Option[int]) -> int { return 0 } See also: book/compiler-stdlib-contract.html , book/cli.html ## E0010 - unknown generic base type Code: E0010 Layer: resolve Symptom: The base type of a generic was not found. Probable cause: Generic base type is misspelled or not imported. Fix: check spelling or import base type with use or pull . Example: use std/core/option.Option let x: Option[int] = Option.None See also: book/compiler-stdlib-contract.html , book/cli.html ## E0011 - a generic type requires at least one argument Code: E0011 Layer: resolve Symptom: A generic type was written without a type argument. Probable cause: Type application is incomplete. Fix: provide one or more type arguments between [ ] . Example: let x: Option = Option.None See also: book/compiler-stdlib-contract.html , book/cli.html ## E0012 - unsupported type Code: E0012 Layer: resolve Symptom: This type form is not yet supported. Probable cause: The type syntax is valid enough to be parsed, but the compiler does not yet accept this form. Fix: Use a supported type form like built-in types, named types, pointers, slices or proc types. Example: let p: *int = &value See also: book/compiler-stdlib-contract.html , book/cli.html ## E0013 - unknown identifier Code: E0013 Layer: resolve Symptom", "lang": "en", "section": "book" }, { "title": "Vitte Glossary", "path": "book/glossary.html", "content": "Vitte Glossary Skip to content Vitte Welcome Documentation Download Source Community News Diagnostics Suggestions Glossary Vitte Book Summary Technical index Checklist This glossary centralizes the basic concepts to avoid redefining them in each chapter. int : type of signed integers, used for calculations without decimal places. string : text type. bool : logical type ( true or false ). proc : declaration of a procedure with inputs and output type. entry : executable entry point of the program. let : creation of a local variable. set : update of an existing variable. if : conditional custody. match : branch selection according to a value form. case : branch of a match . otherwise : backup branch of a match . give : immediate return from a branch. return : End of execution with an exit code. form : Named data structure. pick : closed variant type. Reading Tip: If you are stuck on a keyword during a chapter, come back here, then return to the example immediately. book/glossary.html Back to home", "lang": "en", "section": "book" }, { "title": "Book Home", "path": "book/index.html", "content": "Book Home Skip to content Vitte Welcome Documentation Download Source Community News Diagnostics Suggestions Book Home New beginner entry point: docs/book/poche/summary.html (all-in-pocket format). This book is organized into three complementary layers. The chapters carry the full conceptual progression. The logic section isolates execution mechanisms and code traces. The keywords section documents each lexical element of the language with short examples. Main entry point: docs/book/summary.html . Recommended route if the book feels too dense: docs/book/poche/summary.html . Quick technical entry point: docs/book/technical-index.html . Editorial style guide: docs/book/STYLE.html . Summary Pocket Chapters Glossary Checklist Where to Learn What Getting started and basics: docs/book/chapters/00-foreword.html , docs/book/chapters/01-starting.html , docs/book/chapters/04-syntax.html . Types and data: docs/book/chapters/05-types.html , docs/book/chapters/08-structures.html , docs/book/chapters/11-collections.html . Control and logic: docs/book/chapters/06-procedures.html , docs/book/chapters/07-control.html , docs/book/logique/index.html . Modules and architecture: docs/book/chapters/09-modules.html , docs/book/chapters/15-pipeline.html , docs/book/chapters/20a-overall-architecture.html . Quality and execution: docs/book/chapters/10-diagnostics.html , docs/book/chapters/18-tests.html , docs/book/chapters/20-reproducibility.html . Full projects: docs/book/chapters/21-cli-project.html to docs/book/chapters/26-editor-project.html . Editorial Charter Style: precise, educational, concrete, execution-oriented. Detail level: explain the intent, guard, exit, and state effect. Required frame: Goal -> Example -> Why it matters -> Mental check -> Try this -> Minimal fix . Target length: see the detailed thresholds in docs/book/STYLE.html . Anti-repetition rule: do not redefine the basics ( int , proc , etc.) outside the opening and glossary. book/index.html Back to home", "lang": "en", "section": "book" }, { "title": "Pedagogical Roadmap", "path": "book/roadmap-pedagogique.html", "content": "Pedagogical Roadmap Skip to content Pedagogical Roadmap Upcoming simplifications: novice mode tuning, chapter quality review, diagnostics examples, project tracks.", "lang": "en", "section": "book" }, { "title": "Start in 30 minutes", "path": "book/start-30-min.html", "content": "Start in 30 minutes Skip to content Start in 30 minutes How to read First program Conditions and loops", "lang": "en", "section": "book" }, { "title": "Book Status", "path": "book/status.html", "content": "Book Status Skip to content Book Status Coverage, completeness, and checks are generated from chapters metadata. loading…", "lang": "en", "section": "book" }, { "title": "Stdlib (Selection)", "path": "book/stdlib.html", "content": "Stdlib (Selection) Skip to content Vitte Welcome Documentation Download Source Community News Diagnostics Suggestions Stdlib (Selection) This page is a library map, not a minimal snippet dump. The goal is to show the main families, the responsibilities they own, and the kinds of complete programs they support. Complete Reference Atlas The stdlib now has a wiki-style reference corpus aligned with the actual src/vitte/stdlib tree: one page per family, one page per file, and one SVG portrait per module in the same spirit as the keyword pages. book/stdlib-reference/index.html for the full atlas. book/stdlib-reference/modules/ for the file-by-file directory. book/compiler-stdlib-contract.html for the compiler/runtime contract. Library Families Core : types, strings, memory helpers, panic/runtime-adjacent basics, low-level algorithms. Collections : vector, deque, queue, stack, linked list, hashmap, hashset, graph, matrix. Data : dataset, schema, transform, merge, cleaning, statistics. Json and encoding : parse, builder, stringify, serialize, schema, utf, url, base64, hex, html. Path and io : manipulation, walkers, special locations, globbing, file, buffer, stream, stdio. Math : arithmetic, algebra, logic, geometry, trigonometry, probability, statistics, modular, matrix, vector. Crypto and compression : hashes, HMAC, random, symmetric/asymmetric primitives, huffman, lz, deflate, brotli. Async and threading : future, executor, channel, thread, mutex, threadpool. Kernel and ffi : process, scheduler, users, signals, device, memory, network, ABI-facing integration. Complete Example space demo/report form Report { name: string root: string status: int } pick Outcome { case Ok(summary: string) case Err(code: int) } proc normalize_root(root: string) -> string { if root == \"\" { give \".\" } give root } proc validate_report(r: Report) -> Outcome { if r.name == \"\" { give Outcome.Err(11) } if r.status < 0 { give Outcome.Err(12) } give Outcome.Ok(r.name) } proc render_report(r: Report) -> string { let normalized: string = normalize_root(r.root) give \"{name=\" + r.name + \",root=\" + normalized + \",status=ok}\" } entry main at core/app { let r: Report = Report(\"demo\", \"src/vitte/compiler\", 0) return 0 } This single example is enough to show where future stdlib families plug in: path for root normalization, json for serialization, io for file emission, collections for grouping reports, and async if generation becomes concurrent. How To Read The Catalog Start from the responsibility of the code, not from the module name you happen to remember. Prefer pure families first: core , strings , collections , data . Move to host-facing families only when the problem genuinely touches files, processes, or runtime coordination. Keep bridge/kernel/ffi boundaries explicit because they carry the highest coupling cost. book/stdlib.html Back to home", "lang": "en", "section": "book" }, { "title": "Summary", "path": "book/summary.html", "content": "Summary Skip to content Vitte Welcome Documentation Download Source Community News Diagnostics Suggestions Summary Book Pocket Summary Technical Index Glossary Checklist Pocket Book Pocket Summary Vitte Glossary Editorial Style Guide Editorial Proofreading Checklist Classic Mistakes Projects: CLI (21) -> HTTP (22) -> System (23) -> KV (24) -> Arduino (25) -> Editor (26) Vitte Technical Index Surface grammar (EBNF) Foreword (reading method) Preface (learning trajectory) 1. Get started with Vitte 2. Philosophy of language 3. Structure of a project 4. Essential Syntax 5. Types and values 6. Procedures and contracts 7. Control Instructions 8. Data Structures 9. Modules and organization 10. Diagnostics and errors 11. Collections and iteration 12. Pointers, references and memory 13. Generics 14. Macros 15. Compiler Pipeline 16. Interop and ABI 16a. Vitte Binding with std/bridge 17. Stdlib 17a. stdlib migration plan 18. Testing and validation 19. Performance 20. Reproducibility 20a. Overall Language Architecture 21. CLI Project 22. HTTP Project 23. System Project 24. KV Project 25. Arduino Project 26. Editor Project 27. Grammar Reference 27.1 Language overview 27.2 Glossary and tokens (spaces, comments, identifiers, keywords) 27.3 Literals (numbers, strings, booleans, lists, etc.) 27.4 Expressions (priority, associativity, parentheses) 27.5 Basic instructions (blocks, assignment, expression statements) 27.6 Flow control ( if , loop , for , select/when , match ) 27.7 Functions and scope ( proc , parameters, closures) 27.8 Types and annotations 27.9 Data structures (shapes, picks/cases, lists, slices, pointers) 27.10 Modules and imports ( space , pull , use , share ) 27.11 Diagnostics and error management (lexical/syntactic) 27.12 Formal grammar in EBNF (complete rules) 27.13 Ambiguities and resolution (precedence, LL/LR conflicts, else ) 27.14 AST and grammar mapping -> parser 27.15 Complete commented examples 27.16 Appendices (cheat sheets, conventions, grammar tests) 28. Code conventions 29. Architecture style 30. FAQs 31. Build errors 32. Vitte Module Catalog 33. Suggested Chapters 34. Compiler Mental Model 35. Anatomy of an Error Message 36. Naming Strategies 37. Large-Scale Module Conventions 38. Type-Driven Refactoring 39. Design of stable public APIs 40. Compatibility Management 41. Versioning and Migration 42. Robust Procedure Patterns 43. Common Anti-Patterns in Vitte Code 44. Performance: Measure Before Optimizing 45. Performance: allocations and copies 46. ​​Performance: adapted data structures 47. Repeatable Debugging 48. Tracing and observability 49. Writing Readable Unit Tests 50. Scenario-Oriented Integration Testing 51. Compiler non-regression tests 52. Grammar tests (valid/invalid corpus) 53. Property-based testing for the parser 54. Fuzzing the source input 55. Memory security and invariants 56. Defensive input/output programming 57. Semantic error handling 58. CI pipeline for a Vitte project 59. Risk-oriented code review 60. Sustainable technical documentation 61. Generation of Grammar Diagrams 62. Advanced EBNF Reading of Language 63. Resolution of Syntactic Ambiguities 64. Mapping AST -> IR (practical view) 65. ABI and Vitte interop contracts 66. Macros: use cases and limits 67. Generics: design and compromise 68. Hexagonal architecture in Vitte 69. Complete CLI production-ready project 70. HTTP production-ready complete project 71. Complete project system service 72. Embedded project (memory/time constraints) 73. Team skills development plan 74. Document the documentation Logical elements of Vitte Logic - Conditions Logic - Loops Logic - Matching Logic - Expressions Logic - Types and Contracts Vitte Keywords Keyword coverage Browse keywords Commented keyword gallery Keywords Learning Packs Unused keywords Glossary of compiler errors Keyword entry Keyword proc Keyword let Keyword make Keyword set Keyword type Keyword form Keyword trait Keyword field Keyword pick Keyword case Keyword if Keyword else Keyword otherwise Keyword loop Keyword for Keyword in Keyword break Keyword continue Keyword select Keyword when Keyword match Keyword is Keyword give Keyword emit Keyword asm Keyword unsafe Keyword return Keyword use Keyword space Keyword pull Keyword share Keyword const Keyword macro Keyword as Keyword at Keyword and Keyword or Keyword not Keyword all Keyword bool Keyword string Keyword int Keyword true Keyword false book/summary.html Back to home", "lang": "en", "section": "book" }, { "title": "Vitte Technical Index", "path": "book/technical-index.html", "content": "Vitte Technical Index Skip to content Vitte Welcome Documentation Download Source Community News Diagnostics Suggestions Vitte Technical Index Summary Book Pocket Summary Glossary Checklist This index links language mechanisms, narrative chapters, logical pages and keyword pages so you can find a concept by technical intent. Entry points and orchestration: see docs/book/chapters/01-starting.html , docs/book/chapters/04-syntax.html , docs/book/chapters/keywords/entry.html , docs/book/chapters/keywords/at.html . Procedures and contracts: see docs/book/chapters/06-procedures.html , docs/book/logique/types-et-contrats.html , docs/book/chapters/keywords/proc.html , docs/book/chapters/keywords/give.html , docs/book/chapters/keywords/return.html . Types and data modeling: see docs/book/chapters/05-types.html , docs/book/chapters/08-structures.html , docs/book/chapters/keywords/form.html , docs/book/chapters/keywords/pick.html , docs/book/chapters/keywords/case.html , docs/book/chapters/keywords/type.html . Conditions and guards: see docs/book/logique/conditions.html , docs/book/chapters/07-control.html , docs/book/chapters/keywords/if.html , docs/book/chapters/keywords/else.html , docs/book/chapters/keywords/otherwise.html , docs/book/chapters/keywords/and.html , docs/book/chapters/keywords/or.html , docs/book/chapters/keywords/not.html . Loops and iteration: see docs/book/logique/boucles.html , docs/book/chapters/11-collections.html , docs/book/chapters/keywords/loop.html , docs/book/chapters/keywords/for.html , docs/book/chapters/keywords/in.html , docs/book/chapters/keywords/break.html , docs/book/chapters/keywords/continue.html . Pattern matching and decomposition: see docs/book/logique/matching.html , docs/book/chapters/keywords/match.html , docs/book/chapters/keywords/select.html , docs/book/chapters/keywords/when.html , docs/book/chapters/keywords/is.html . Expressions and conversions: see docs/book/logique/expressions.html , docs/book/chapters/keywords/as.html , docs/book/chapters/keywords/int.html , docs/book/chapters/keywords/bool.html , docs/book/chapters/keywords/string.html . Modules and organization: see docs/book/chapters/03-project.html , docs/book/chapters/09-modules.html , docs/book/chapters/keywords/space.html , docs/book/chapters/keywords/pull.html , docs/book/chapters/keywords/use.html , docs/book/chapters/keywords/share.html . Interop and unsafe boundaries: see docs/book/chapters/12-pointers.html , docs/book/chapters/16-interop.html , docs/book/chapters/keywords/unsafe.html , docs/book/chapters/keywords/asm.html . Quality, tests, and reproducibility: see docs/book/chapters/10-diagnostics.html , docs/book/chapters/18-tests.html , docs/book/chapters/20-reproducibility.html . Performance and architecture: see docs/book/chapters/19-performance.html , docs/book/chapters/29-style.html . book/technical-index.html Back to home", "lang": "en", "section": "book" } ] }