Read-only mirrors. Development, issues and pull requests are on GitHub.

summaryrefslogtreecommitdiffhomepage
path: root/content
diff options
context:
space:
mode:
authorLeitwolf2026-11-16 14:49:23 +0300
committerGitHub2026-11-16 14:49:23 +0300
commit324048967d1fb198e3489b1722ca1ff317338550 (patch)
treee270ad6dc86200cc79cbdccfa1ef6de1da8aff0d /content
parent45c1bb14326cbee8fe57c6f639550e8eadd81f0a (diff)
parent4ee77681379619b3fab7b8b33446a67164216cc8 (diff)
downloadtazel.net-main.tar.gz
Merge pull request #10 from Progmasoft/content/new-tazelHEADmain
Rewrite the site for the Tazel of C, C++, Objective-C, Objective-C++ and Zig
Diffstat (limited to 'content')
-rw-r--r--content/de-DE/docs/1.getting-started/1.installation.md52
-rw-r--r--content/de-DE/docs/1.getting-started/2.first-project.md166
-rw-r--r--content/de-DE/docs/1.getting-started/3.releases.md38
-rw-r--r--content/de-DE/docs/2.reference/1.commands.md119
-rw-r--r--content/de-DE/docs/2.reference/2.module-file.md112
-rw-r--r--content/de-DE/docs/2.reference/3.build-file.md143
-rw-r--r--content/de-DE/docs/3.extending/1.plugins.md87
-rw-r--r--content/de-DE/docs/4.internals/1.architecture.md52
-rw-r--r--content/en-US/docs/1.getting-started/1.installation.md51
-rw-r--r--content/en-US/docs/1.getting-started/2.first-project.md166
-rw-r--r--content/en-US/docs/1.getting-started/3.releases.md35
-rw-r--r--content/en-US/docs/2.reference/1.commands.md548
-rw-r--r--content/en-US/docs/2.reference/2.module-file.md111
-rw-r--r--content/en-US/docs/2.reference/2.project-file.md380
-rw-r--r--content/en-US/docs/2.reference/3.build-file.md143
-rw-r--r--content/en-US/docs/2.reference/3.lockfile.md98
-rw-r--r--content/en-US/docs/3.extending/1.plugins.md315
-rw-r--r--content/en-US/docs/4.internals/1.architecture.md179
-rw-r--r--content/fr-FR/docs/1.getting-started/1.installation.md51
-rw-r--r--content/fr-FR/docs/1.getting-started/2.first-project.md161
-rw-r--r--content/fr-FR/docs/1.getting-started/3.releases.md32
-rw-r--r--content/fr-FR/docs/2.reference/1.commands.md121
-rw-r--r--content/fr-FR/docs/2.reference/2.module-file.md112
-rw-r--r--content/fr-FR/docs/2.reference/3.build-file.md143
-rw-r--r--content/fr-FR/docs/3.extending/1.plugins.md87
-rw-r--r--content/fr-FR/docs/4.internals/1.architecture.md52
-rw-r--r--content/he-IL/docs/1.getting-started/1.installation.md42
-rw-r--r--content/he-IL/docs/1.getting-started/2.first-project.md59
-rw-r--r--content/he-IL/docs/1.getting-started/3.releases.md29
-rw-r--r--content/ru-RU/docs/1.getting-started/1.installation.md51
-rw-r--r--content/ru-RU/docs/1.getting-started/2.first-project.md165
-rw-r--r--content/ru-RU/docs/1.getting-started/3.releases.md35
-rw-r--r--content/ru-RU/docs/2.reference/1.commands.md119
-rw-r--r--content/ru-RU/docs/2.reference/2.module-file.md110
-rw-r--r--content/ru-RU/docs/2.reference/3.build-file.md143
-rw-r--r--content/ru-RU/docs/3.extending/1.plugins.md86
-rw-r--r--content/ru-RU/docs/4.internals/1.architecture.md50
37 files changed, 2740 insertions, 1703 deletions
diff --git a/content/de-DE/docs/1.getting-started/1.installation.md b/content/de-DE/docs/1.getting-started/1.installation.md
index ee52ffc..d13ed88 100644
--- a/content/de-DE/docs/1.getting-started/1.installation.md
+++ b/content/de-DE/docs/1.getting-started/1.installation.md
@@ -1,42 +1,50 @@
---
title: Installation
-description: Tazel und die Tala-Werkzeuge installieren, die es startet.
+description: Tazel aus dem Quellcode bauen und die Compiler und Werkzeuge installieren, die es aufruft.
---
<!-- SPDX-FileCopyrightText: 2026 Progmasoft <[email protected]> -->
<!-- SPDX-License-Identifier: AGPL-3.0-or-later -->
-Tazel ist ein Kotlin-Programm für die JVM, ein Rechner braucht also eine Java-Laufzeit 25 oder neuer. Es kompiliert
-selbst nichts: `check`, `build`, `run` und `test` starten Talac, `fmt` startet talafmt und `lint` startet talalint.
+Tazel ist ein Kotlin-Programm für die JVM. Es kompiliert selbst nichts: Es ruft die Compiler und Werkzeuge auf, die
+es im `PATH` findet. Noch ist keine Version veröffentlicht, daher wird Tazel aus seinem Quellcode gebaut.
-## Tazel bauen
+## Was ein Rechner braucht
+
+| Wofür | Installieren |
+| --- | --- |
+| Tazel selbst | ein JDK 25, etwa Eclipse Temurin 25 |
+| Ziele in C, C++, Objective-C und Objective-C++ | Clang oder GCC; Clang baut auch für andere Triples |
+| Zig-Ziele und `zig cc` als C-Compiler | Zig |
+| `tazel fmt` | clang-format für die C-Familie, `zig fmt` (Teil von Zig) für Zig |
+| `tazel lint` | clang-tidy |
-Tazel wird aus seinem Quellcode mit dem Gradle-Wrapper gebaut, der ein JDK 25 braucht. `installDist` schreibt die
-Starter, `tazel` und `tazel.bat`, nach `build/install/tazel/bin`. Nehmen Sie diesen Ordner in `PATH` auf.
+Jedes Werkzeug wird nur für die Befehle und Ziele gebraucht, die es verwenden: Ein Modul nur aus C++ braucht kein Zig.
-```bash [Linux und macOS]
+## Tazel bauen
+
+```bash
git clone https://github.com/Progmasoft/tazel.git
cd tazel
./gradlew installDist
```
-```powershell [Windows]
-git clone https://github.com/Progmasoft/tazel.git
-cd tazel
-.\gradlew.bat installDist
-```
+Unter Windows führen Sie in PowerShell `gradlew.bat installDist` aus. Das Programm liegt in `build/install/tazel`:
+Legen Sie sein Verzeichnis `bin` in den `PATH` und prüfen Sie es:
-`tazel version` gibt die installierte Version aus.
+```bash
+tazel version
+```
-## Die Tala-Werkzeuge
+```text
+tazel 0.1.0
+```
-Tazel findet jedes Werkzeug über `TAZEL_TALAC`, `TAZEL_TALAFMT` oder `TAZEL_TALALINT`, dann in seiner eigenen
-Installation, dann über `PATH`. Jedes Werkzeug hat eigene Releases:
+## Wo Tazel Werkzeuge sucht
-| Werkzeug | Verwendet von | Quellcode |
-| -------- | ------------------------------- | ------------------------------------------------------------- |
-| Talac | `check`, `build`, `run`, `test` | [Progmasoft/tala](https://github.com/Progmasoft/tala) |
-| talafmt | `fmt` | [Progmasoft/talafmt](https://github.com/Progmasoft/talafmt) |
-| talalint | `lint` | [Progmasoft/talalint](https://github.com/Progmasoft/talalint) |
+Tazel nimmt `clang`, `gcc`, `zig`, `clang-format` und `clang-tidy` aus dem `PATH`. Ein Ziel kann seinen Compiler mit
+`compiler = Compiler.CLANG`, `Compiler.GCC` oder `Compiler.ZIG_CC` nennen; ohne Angabe nimmt Tazel den ersten
+gefundenen, der für das Triple des Ziels baut. Jedes Werkzeug liest seine eigene Konfiguration, etwa `.clang-format`
+und `.clang-tidy`.
-Weiter: [ein erstes Projekt](/docs/getting-started/first-project).
+Weiter: [Ihr erstes Projekt](/docs/getting-started/first-project).
diff --git a/content/de-DE/docs/1.getting-started/2.first-project.md b/content/de-DE/docs/1.getting-started/2.first-project.md
index 72f1fc0..feafa55 100644
--- a/content/de-DE/docs/1.getting-started/2.first-project.md
+++ b/content/de-DE/docs/1.getting-started/2.first-project.md
@@ -1,60 +1,162 @@
---
-title: Ein erstes Projekt
-description: Ein Tala-Projekt in wenigen Zeilen schreiben, dann bauen, starten, formatieren und prüfen.
+title: Ihr erstes Projekt
+description: Ein Modul mit einer C-Bibliothek, einem C++-Programm und einem Test, gebaut, gestartet und getestet mit Tazel.
---
<!-- SPDX-FileCopyrightText: 2026 Progmasoft <[email protected]> -->
<!-- SPDX-License-Identifier: AGPL-3.0-or-later -->
-Ein Projekt ist ein Ordner mit einer Projektdatei. Seine Quellen sind die `.tala`-Dateien unter `Sources/`, und `entry`
-nennt die Klasse, deren `public static void Main()` das Programm startet.
+Ein Modul ist ein Verzeichnis mit einem `MODULE.kts` an seiner Wurzel. Jedes Verzeichnis darunter mit einem
+`BUILD.kts` ist ein Paket, und jedes Ziel eines Pakets hat ein Label: `//app/:greeter` ist das Ziel `greeter` von
+`app/BUILD.kts`.
-```kotlin [BUILD.kts]
-project {
- name = "Example"
+```text
+greeter/
+├── MODULE.kts
+├── core/
+│ ├── BUILD.kts
+│ ├── include/core/greet.h
+│ └── src/greet.c
+├── app/
+│ ├── BUILD.kts
+│ └── src/main.cpp
+└── tests/
+ ├── BUILD.kts
+ └── greet_test.cpp
+```
+
+## Das Modul
+
+```kotlin
+// MODULE.kts
+module {
+ name = "greeter"
+ version = "0.1.0"
}
+```
+
+## Eine C-Bibliothek
+
+```kotlin
+// core/BUILD.kts
+isPublic = true
+
+c.staticlib("core") {
+ sources(glob("src/*.c"))
+ headers("include")
+ standard = CStandard.C17
+}
+```
-sources {
- executable {
- entry = "Example.Program"
- }
+`isPublic = true` erlaubt den anderen Paketen des Moduls, von den Zielen dieser Datei abzuhängen. `headers("include")`
+lässt `#include <core/greet.h>` in `core` und in jedem Ziel wirken, das davon abhängt.
+
+```c
+// core/include/core/greet.h
+#pragma once
+const char *greeting(void);
+```
+
+```c
+// core/src/greet.c
+#include <core/greet.h>
+const char *greeting(void) { return "Hello"; }
+```
+
+## Ein C++-Programm
+
+```kotlin
+// app/BUILD.kts
+cpp.bin("greeter") {
+ sources(glob("src/*.cpp"))
+ depends("//core/:core")
+ standard = CppStandard.CPP20
}
```
-```tala [Sources/Main.tala]
-namespace Example;
+```cpp
+// app/src/main.cpp
+#include <cstdio>
+extern "C" {
+#include <core/greet.h>
+}
-public class Program {
- public static void Main() {
- Console.Println("Hello from Tala!");
- }
+int main(int argc, char **argv)
+{
+ std::printf("%s, %s!\n", greeting(), argc > 1 ? argv[1] : "world");
}
```
## Bauen und starten
-```bash [terminal]
-tazel build
-tazel run -- first second
+```bash
+tazel build //app/:greeter
```
-`tazel build` schreibt `build/debug/Example`, unter Windows `Example.exe`. `tazel run` baut das Programm und startet
-es; was nach `--` folgt, geht ungelesen an das Programm. Ein zweites `tazel build` ohne Änderung meldet das Ziel als
-aktuell und startet keinen Compiler.
+```text
+ Compiling //core/:core src/greet.c
+ Archiving //core/:core
+ Compiling //app/:greeter src/main.cpp
+ Linking //app/:greeter
+ Built 2 target(s) for x86_64-unknown-linux-gnu, debug; 4 command(s) run
+```
-## Formatieren und prüfen
+Ein zweiter Build führt nichts aus, weil sich keine Eingabe geändert hat:
-```bash [terminal]
-tazel fmt -- --check
-tazel lint -- --fix
+```text
+ Built 2 target(s) for x86_64-unknown-linux-gnu, debug; 0 command(s) run
```
-Optionen nach `--` gehen an talafmt und talalint, also meldet `tazel fmt -- --check` nur, und `tazel lint -- --fix`
-wendet die Korrekturen an, die es kann.
+`tazel run` baut ein Programm und startet es; was nach `--` folgt, geht an das Programm:
+
+```bash
+tazel run //app/:greeter -- Ada
+```
+
+```text
+Hello, Ada!
+```
+
+Die Ergebnisse liegen in `.tazel/out/<triple>/<mode>`, hier `.tazel/out/x86_64-unknown-linux-gnu/debug`. `--release`
+baut im Release-Modus.
+
+## Ein Test
+
+```kotlin
+// tests/BUILD.kts
+cpp.test("greet") {
+ sources("greet_test.cpp")
+ depends("//core/:core")
+}
+```
+
+```cpp
+// tests/greet_test.cpp
+#include <cstring>
+extern "C" {
+#include <core/greet.h>
+}
+
+int main() { return std::strcmp(greeting(), "Hello") == 0 ? 0 : 1; }
+```
+
+Ein Test besteht, wenn sein Programm mit 0 endet. `//tests/...` nimmt jedes Ziel in `tests/` und darunter:
+
+```bash
+tazel test //tests/...
+```
+
+```text
+ Compiling //tests/:greet greet_test.cpp
+ Linking //tests/:greet
+ Built 2 target(s) for x86_64-unknown-linux-gnu, debug; 2 command(s) run
+ PASSED //tests/:greet in 0.0s
+ Tested 1 test(s): 1 passed, 0 failed
+```
::note
-ViGet liefert keine Tala-Pakete aus. Ein Projekt, das eine Abhängigkeit des Builds deklariert, Bibliotheksziele und die
-Erstellung von `.vipkg` werden mit Namen und Exit-Code 1 abgelehnt.
+Ohne Label nehmen `build`, `run` und `test` das Paket des aktuellen Verzeichnisses. `//...` nimmt das ganze Modul.
::
-Weiter: jeder Block der [Projektdatei](/docs/reference/project-file) und jeder [Befehl](/docs/reference/commands).
+Weiter: [die Befehle](/docs/reference/commands) und jede Einstellung von [MODULE.kts](/docs/reference/module-file)
+und [BUILD.kts](/docs/reference/build-file).
diff --git a/content/de-DE/docs/1.getting-started/3.releases.md b/content/de-DE/docs/1.getting-started/3.releases.md
index a003c7c..f09a874 100644
--- a/content/de-DE/docs/1.getting-started/3.releases.md
+++ b/content/de-DE/docs/1.getting-started/3.releases.md
@@ -1,30 +1,32 @@
---
-title: Releases und Unterstützung
-description: Wie Tazel nummeriert wird und wie lange Rolling-, LTS- und ELTS-Releases unterstützt werden.
+title: Versionen
+description: Wie Tazel seine Versionen nummeriert und wie lange jede Art von Version unterstützt wird.
---
<!-- SPDX-FileCopyrightText: 2026 Progmasoft <[email protected]> -->
<!-- SPDX-License-Identifier: AGPL-3.0-or-later -->
-Eine Version von Tazel hat vier Zahlen: `MAJOR.SEMIMAJOR.MINOR.PATCH`, etwa `0.4.0.3`. Jedes Release hat ein Tag
-`tazel-<version>` und Versionshinweise auf [GitHub](https://github.com/Progmasoft/tazel/releases).
+Noch ist keine Version von Tazel veröffentlicht; die erste wird 0.1.0 sein. Was sie bisher enthält, steht im
+[Abschnitt Unreleased des Changelogs](https://github.com/Progmasoft/tazel/blob/main/CHANGELOG.md#unreleased).
-## Drei Arten von Releases
+## Versionsnummern
-| Art | Unterstützt für | Welche Releases |
-| --- | --- | --- |
-| Rolling | 6 Monate | jedes Release, das weder LTS noch ELTS ist, und jedes Release vor `1.0.0.0` |
-| LTS (Long-Term Support) | 5 Jahre | die Linie `A.0` jeder `MAJOR` ab `1.0.0.0` |
-| ELTS (Extended Long-Term Support) | 12 Jahre | die LTS-Linie der `MAJOR` 1, 4, 7 und jeder dritten danach |
+Versionen folgen [Semantic Versioning](https://semver.org): `MAJOR.MINOR.PATCH`. Eine Patch-Version behebt Fehler,
+eine Minor-Version fügt hinzu, und eine Major-Version darf ändern, was vorher funktionierte. Tags heißen
+`tazel-0.1.0`, und ein veröffentlichter Tag wird nie verschoben.
+
+## Arten von Versionen
-Die Zeit zählt ab dem ersten Release der Linie. Eine unterstützte Linie erhält Korrekturen von Fehlern und
-Sicherheitsproblemen als neue `MINOR`- und `PATCH`-Releases; neue Funktionen erhält sie nicht, die kommen in den
-Rolling-Releases.
+| Art | Unterstützt für | Welche Versionen |
+| --- | --- | --- |
+| Rolling | 6 Monate | jede Version vor 1.0.0 und jede Version außerhalb einer LTS- oder ELTS-Linie |
+| LTS | 5 Jahre | die Linie MAJOR.0 der übrigen Major-Versionen: 2.0.x, 3.0.x, 5.0.x, 6.0.x und weiter |
+| ELTS | 12 Jahre | die Linie MAJOR.0 der Major-Versionen 1, 4, 7 und jeder dritten danach: 1.0.x, 4.0.x, 7.0.x |
-## Welche passt
+Eine unterstützte Linie erhält nur Fehlerbehebungen, als ihre Patch-Versionen.
-- **Rolling** bringt jede Funktion zuerst. Nehmen Sie das neueste Release; das davor bleibt 6 Monate unterstützt.
-- **LTS** bleibt 5 Jahre auf einer Linie, für Projekte, die gelegentlich aktualisieren.
-- **ELTS** bleibt 12 Jahre auf einer Linie, für Produkte, die Tala-Programme lange ausliefern.
+## Das frühere Tazel
-Jedes Release von Tazel vor `1.0.0.0` ist Rolling.
+Ein früheres Programm gleichen Namens, Versionen 0.1.0 bis 0.4.0.3, ist als
+[Progmasoft/tazel-legacy](https://github.com/Progmasoft/tazel-legacy) archiviert. Seine Versionen sind nicht die
+Versionen dieses Tazel, das wieder bei 0.1.0 beginnt.
diff --git a/content/de-DE/docs/2.reference/1.commands.md b/content/de-DE/docs/2.reference/1.commands.md
new file mode 100644
index 0000000..cc6b653
--- /dev/null
+++ b/content/de-DE/docs/2.reference/1.commands.md
@@ -0,0 +1,119 @@
+---
+title: Befehle
+description: Jeder Befehl von tazel, seine Optionen und die Labels, die er nimmt.
+---
+
+<!-- SPDX-FileCopyrightText: 2026 Progmasoft <[email protected]> -->
+<!-- SPDX-License-Identifier: AGPL-3.0-or-later -->
+
+```text
+tazel <command> [options] [labels]
+```
+
+| Befehl | Was er tut |
+| --- | --- |
+| `build` | baut Ziele, etwa `tazel build //app/:greeter` oder `tazel build //...` |
+| `run` | baut ein `bin`-Ziel und startet es; was nach `--` folgt, geht an das Programm |
+| `test` | baut Testziele und führt sie aus; was nach `--` folgt, geht an jeden Test |
+| `fmt` | formatiert Quellen und Header von Zielen mit clang-format und `zig fmt`; `--check` meldet stattdessen |
+| `lint` | prüft die C-Quellen von Zielen mit clang-tidy; `--fix` wendet seine Korrekturen an |
+| `custom` | führt einen Befehl aus `tazel_custom.txt` aus oder listet sie auf |
+| `version` | gibt die Version von Tazel aus |
+| `help` | gibt die Hilfe aus |
+
+Ein vertippter Befehl bekommt einen Vorschlag für den nächstliegenden.
+
+## Labels
+
+| Label | Bedeutet |
+| --- | --- |
+| `//:x` | das Ziel `x` des `BUILD.kts` an der Wurzel |
+| `//dir/:x` | das Ziel `x` von `dir/BUILD.kts` |
+| `:x` | das Ziel `x` desselben `BUILD.kts`, in einer Projektdatei |
+| `@name//:x` | das Ziel `x` der Abhängigkeit `name`: ihr Name, ihr Alias oder der Name ihres lokalen Blocks |
+| `//dir/...` | jedes Ziel von `dir/BUILD.kts` und der Pakete darunter |
+| `//...` | jedes Ziel des Moduls |
+
+Ohne Label nehmen `build`, `run` und `test` das Paket des aktuellen Verzeichnisses. Ein Muster nimmt keinen Test mit
+dem Tag `MANUAL`; ein solcher Test läuft nur, wenn er genannt wird.
+
+## build, run und test
+
+| Option | Wirkung |
+| --- | --- |
+| `--release` | baut im Release-Modus; ohne sie im Debug-Modus |
+| `--triple <triple>` | baut für dieses LLVM-Target-Triple, etwa `aarch64-unknown-linux-gnu`; ohne sie für dieses Gerät |
+
+Jedes Ziel wird für jedes Triple gebaut, das es nennt und das der Befehl verlangt, im Build-Modus des Befehls. Die
+Ergebnisse gehen nach `.tazel/out/<triple>/<mode>`. Jedes Kompilieren, Archivieren, Linken und jeder Zig-Build läuft
+nur erneut, wenn sich seine Befehlszeile, seine Umgebung oder der Inhalt einer gelesenen Datei geändert hat oder eine
+geschriebene Ausgabe fehlt oder verändert ist.
+
+`tazel test` führt jeden Test in seinem Ausgabeverzeichnis aus, neben seinen Daten, mit seinen `args` und `env`. Ein
+Test besteht, wenn er mit 0 endet. Tests laufen nebeneinander, außer denen mit dem Tag `EXCLUSIVE`, die allein laufen.
+Ein Test wird bei seinem Zeitlimit gestoppt, bei `flaky = true` bis zu dreimal wiederholt und mit `TEST_TOTAL_SHARDS`
+und `TEST_SHARD_INDEX` in `shards` aufgeteilt. Ein bestandener Test läuft nicht erneut, solange Programm, Daten,
+Argumente und Umgebung gleich sind, außer er hat den Tag `NO_CACHE`.
+
+## fmt und lint
+
+```bash
+tazel fmt //...
+tazel fmt --check //...
+tazel lint //...
+tazel lint --fix //app/...
+```
+
+`fmt` formatiert die Quellen, Header-Verzeichnisse und textuellen Header der gewählten Ziele mit clang-format (C, C++,
+Objective-C, Objective-C++) und `zig fmt` (Zig); `--check` meldet, was nicht formatiert ist, und ändert nichts.
+
+`lint` schreibt die Kompilierdatenbank der gewählten Ziele und ihrer Bibliotheken nach
+`.tazel/out/<triple>/<mode>/compile_commands.json`, kopiert sie für Editoren nach `.tazel/compile_commands.json` und
+führt clang-tidy auf jeder C-Übersetzungseinheit aus. `--fix` wendet die Korrekturen an, eine Einheit nach der
+anderen. Zig-Ziele werden übersprungen.
+
+Bei beiden geht, was nach `--` folgt, an das Werkzeug. Jedes Werkzeug liest seine eigene Konfiguration, etwa
+`.clang-format` und `.clang-tidy`.
+
+## custom
+
+`tazel custom` führt die Befehle aus `tazel_custom.txt` an der Wurzel des Moduls aus; `tazel custom` allein listet sie.
+
+```text
+# tazel_custom.txt
+format-check: ("tazel" "fmt" "--check" "//...");
+
+all:
+ ("tazel" "build" "//...")
+ ("tazel" "test" "//...");
+
+hello: s("echo hello from the shell");
+
+build with: ("tazel" "build" <1> <2>);
+```
+
+- Ein Befehl ist ein Name, `:`, ein oder mehrere Schritte und `;`. Ein Name kann mehrere Wörter haben:
+ `tazel custom build with`.
+- Ein Schritt `("program" "argument" ...)` führt das Programm mit diesen Argumenten aus. Zeichenketten stehen in
+ `"..."`, `'...'` oder `` `...` ``; es gibt keine Escape-Zeichen.
+- Ein Schritt `s("...")` gibt eine Befehlszeile an die Shell: `sh` unter Linux und macOS, `cmd` unter Windows.
+- `<1>`, `<2>` und weiter geben die Argumente der Befehlszeile nach Position weiter; `<*>` gibt alle weiter. `s(...)`
+ nimmt keine. `tazel custom first -- second` gibt `second` an `first`, wenn es einen Befehl `first second` gibt.
+- `#` beginnt einen Kommentar bis zum Zeilenende; `<# ... #>` ist ein Kommentar über mehrere Zeilen.
+
+`tazel_options.txt` an der Wurzel des Moduls hält die Optionen von Tazel selbst:
+
+```text
+sandboxing-with-microvm: false;
+```
+
+Mit `sandboxing-with-microvm: true` sollen eigene Befehle in einer MicroVM laufen, die diese Version nicht startet,
+also brechen sie mit einem Fehler ab. `microvm-network`, `microvm-memory` und `microvm-cpus` stellen diese MicroVM
+ein.
+
+## version und help
+
+```bash
+tazel version
+tazel help
+```
diff --git a/content/de-DE/docs/2.reference/2.module-file.md b/content/de-DE/docs/2.reference/2.module-file.md
new file mode 100644
index 0000000..d15571a
--- /dev/null
+++ b/content/de-DE/docs/2.reference/2.module-file.md
@@ -0,0 +1,112 @@
+---
+title: MODULE.kts
+description: Die Datei an der Wurzel eines Moduls: sein Name, seine Abhängigkeiten und wie es gebaut wird.
+---
+
+<!-- SPDX-FileCopyrightText: 2026 Progmasoft <[email protected]> -->
+<!-- SPDX-License-Identifier: AGPL-3.0-or-later -->
+
+Ein Modul hat ein `MODULE.kts` an seiner Wurzel. Es ist ein Kotlin-Skript; `module { }` ist der einzige Block, den es
+haben muss.
+
+```kotlin
+module {
+ name = "greeter"
+ version = "1.2.0"
+ description = "Greets people."
+ authors("Ada Lovelace", "Alan Turing")
+ license = "MIT"
+}
+
+dependencies {
+ implementation("Publisher") {
+ name = "toml"
+ version = "1.0.0"
+ }
+ testImplementation("Progmasoft") {
+ name = "catch3"
+ version = "0.4.0"
+ }
+ localImplementation {
+ name = "libs"
+ include(glob("libs/*.vipkg"))
+ }
+}
+
+execution {
+ jobs = 8
+ keepGoing = false
+}
+```
+
+## module
+
+| Einstellung | Wert |
+| --- | --- |
+| `name` | der Name des Moduls; Pflicht |
+| `version` | eine Semantic Version, etwa `1.2.0` |
+| `description` | ein Satz über das Modul |
+| `authors(...)` | seine Autorinnen und Autoren |
+| `license` | ein SPDX-Lizenzausdruck, etwa `MIT` oder `Apache-2.0 OR MIT` |
+
+## dependencies
+
+| Block | Gibt |
+| --- | --- |
+| `implementation("Publisher") { name; version; alias }` | ein Paket aus ViGet, von dem jedes Ziel abhängen kann |
+| `testImplementation("Publisher") { ... }` | dasselbe, nur für Testziele |
+| `localImplementation { name; include(...) }` | Pakete aus `.vipkg`-Dateien des Moduls |
+| `localTestImplementation { ... }` | dasselbe, nur für Testziele |
+
+Der Herausgeber ist ein [Progmasoft Account](https://progmasoft.com). Ein Ziel nennt ein Ziel einer Abhängigkeit mit
+`@name//:x`, wobei `name` der `name` der Abhängigkeit, ihr `alias` oder der `name` eines lokalen Blocks ist. Ein lokaler
+Block, dessen `include` mehrere Pakete nimmt, gibt ihnen einen Namen; derselbe Zielname in zweien davon ist ein Fehler.
+
+::note
+Diese Version von Tazel liest die Abhängigkeiten und prüft die Labels, die sie nennen; sie lädt keine Pakete aus ViGet
+herunter. Die Versionen, die ein Modul auflöst, werden in `LOCK.sqlite3` an seiner Wurzel festgehalten, der Lockdatei
+von Tazel, die diese Version nicht schreibt.
+::
+
+## viget
+
+```kotlin
+viget {
+ push = true
+ pushTarget("//core/:core", "//app/:greeter")
+ exclude(glob("docs/**"))
+}
+```
+
+`pushTarget` nennt die Ziele, die ein Paket des Moduls enthält; ihr `BUILD.kts` muss `isPublic = true` haben.
+`exclude` lässt Dateien aus dem Paket heraus. `push` ist standardmäßig `false`.
+
+## cache
+
+```kotlin
+cache {
+ local = true
+ keep = 8
+ remote("https://cache.example.com") {
+ read = true
+ write = false
+ token = env("TAZEL_CACHE_TOKEN")
+ }
+}
+```
+
+`local` (Standard `true`) und `keep` (behaltene Ergebnisse je Ziel, Standard `8`) beschreiben den lokalen Cache;
+`remote(...)` fügt einen geteilten hinzu, mit `read` (Standard `true`), `write` (Standard `false`), `token`,
+`publicKey` und `signingKey`. `env("NAME")` liest eine Variable der Umgebung, damit kein Geheimnis in der Datei steht.
+
+## execution
+
+| Einstellung | Standard | Wirkung |
+| --- | --- | --- |
+| `jobs` | die Zahl der Prozessoren | wie viele Befehle gleichzeitig laufen |
+| `memory` | keine Grenze | eine Grenze wie `16.gigabytes` |
+| `keepGoing` | `false` | nach einem Fehler die Befehle starten, die nicht davon abhängen |
+| `remote(url) { token }` | keiner | ein Rechner, der die Befehle ausführt |
+
+Diese Version von Tazel wirkt auf `jobs` und `keepGoing`; die übrigen Einstellungen von `cache` und `execution` werden
+gelesen und geprüft.
diff --git a/content/de-DE/docs/2.reference/3.build-file.md b/content/de-DE/docs/2.reference/3.build-file.md
new file mode 100644
index 0000000..c9ef224
--- /dev/null
+++ b/content/de-DE/docs/2.reference/3.build-file.md
@@ -0,0 +1,143 @@
+---
+title: BUILD.kts
+description: Die Ziele eines Pakets und jede Einstellung, die ein Ziel haben kann.
+---
+
+<!-- SPDX-FileCopyrightText: 2026 Progmasoft <[email protected]> -->
+<!-- SPDX-License-Identifier: AGPL-3.0-or-later -->
+
+Jedes Paket hat ein `BUILD.kts`, ein Kotlin-Skript, das seine Ziele deklariert. Eine Einstellung, die eine Sprache
+oder Zielart nicht hat, ist ein Kompilierfehler der Datei, also zeigt ein Editor sie, bevor Tazel läuft.
+
+## Ziele
+
+| Sprache | Quellen | Arten |
+| --- | --- | --- |
+| `c` | `.c` | `bin`, `staticlib`, `sharedlib`, `test` |
+| `cpp` | `.cpp`, `.cc`, `.cxx` | dieselben |
+| `objc` | `.m` | dieselben |
+| `objcpp` | `.mm` | dieselben |
+| `zig` | die Wurzeldatei `.zig` | dieselben |
+
+```kotlin
+c.staticlib("core") { ... } // //core/:core
+cpp.bin("greeter") { ... } // a program
+zig.test("tool") { ... } // a test
+```
+
+Ein Ziel hat eine Sprache. Ziele verschiedener Sprachen verbinden sich über `depends`: Ein C++-Programm kann von einer
+C-Bibliothek und von einer Zig-Bibliothek abhängen, die einen C-Header anbietet.
+
+## Sichtbarkeit
+
+`isPublic` oben in der Datei ist standardmäßig `false`: Nur die Ziele derselben Datei dürfen von ihren Zielen
+abhängen. `isPublic = true` öffnet sie für die anderen Pakete des Moduls und für die Module, die davon abhängen.
+
+## Jedes Ziel
+
+| Einstellung | Wirkung |
+| --- | --- |
+| `sources(...)` | die Quelldateien: Pfade oder `glob("src/**/*.c")` |
+| `depends(...)` | Labels der Ziele, die es verwendet |
+| `targetTriple(...)` | die LLVM-Target-Triples, für die es gebaut wird; Standard: das dieses Geräts |
+| `data(...)` | Dateien, die für `run` und `test` neben das Programm kopiert werden |
+| `outputName` | der Dateiname der Ausgabe; Standard: der Zielname |
+
+## Triples, Build-Modi und Bedingungen
+
+Der Block eines Ziels läuft einmal für jedes Triple und jeden Build-Modus. `OS` und `ARCH` kommen aus dem Triple,
+`BUILD_MODE` aus dem Befehl, also ist eine Bedingung schlichtes Kotlin:
+
+```kotlin
+cpp.bin("greeter") {
+ sources(glob("src/**/*.cpp"))
+ targetTriple("x86_64-unknown-linux-gnu", "aarch64-apple-darwin", "x86_64-pc-windows-msvc")
+
+ when (BUILD_MODE) {
+ BuildMode.DEBUG -> sanitize(Sanitizer.ADDRESS, Sanitizer.UNDEFINED)
+ BuildMode.RELEASE -> {
+ optimize = Optimize.SPEED
+ lto = Lto.THIN
+ strip = true
+ }
+ }
+ when (OS) {
+ Os.WINDOWS -> links("ws2_32")
+ Os.LINUX -> links("dl")
+ Os.MACOS -> frameworks("CoreFoundation")
+ else -> {}
+ }
+}
+```
+
+## Ziele in C, C++, Objective-C und Objective-C++
+
+| Einstellung | Werte und Standard |
+| --- | --- |
+| `exclude(...)` | Quellen, die ausgelassen werden |
+| `headers(...)` | Header-Verzeichnisse, die hier und von abhängigen Zielen gesehen werden |
+| `privateHeaders(...)` | Header-Verzeichnisse, die nur hier gesehen werden |
+| `textualHeaders(...)` | Header, die eingebunden, aber nie allein kompiliert werden |
+| `includePrefix`, `stripIncludePrefix` | ändern den Pfad, unter dem abhängige Ziele Header einbinden |
+| `compiler` | `Compiler.CLANG`, `GCC`, `ZIG_CC`, `MSVC`, `CLANG_CL`; Standard: der erste gefundene, der für das Triple baut. Diese Version baut mit Clang, GCC und `zig cc`; `MSVC` und `CLANG_CL` brechen den Build mit einem Fehler ab |
+| `standard` | C: `CStandard.C89` bis `C23`; C++ und Objective-C++: `CppStandard.CPP11` bis `CPP26`; Standard: der neueste, den der Compiler kann |
+| `gnuExtensions` | standardmäßig `false` |
+| `defines(...)`, `privateDefines(...)` | Makros für hier und abhängige Ziele oder nur für hier |
+| `flags(...)` | weitere Compiler-Flags |
+| `warnings` | `Warnings.ALL`, `DEFAULT`, `NONE`; Standard `DEFAULT` |
+| `warningsAsErrors` | standardmäßig `false` |
+| `precompiledHeader` | ein Header, der einmal kompiliert wird |
+| `debugInfo` | `DebugInfo.NONE`, `FULL`, `SPLIT`; Standard: `FULL` in Debug, `NONE` in Release |
+| `optimize` | `Optimize.NONE`, `SIZE`, `SPEED`; Standard: `NONE` in Debug, `SPEED` in Release |
+| `lto` | `Lto.NONE`, `THIN`, `FULL`; Standard `NONE` |
+| `strip` | standardmäßig `false` |
+| `sanitize(...)` | `Sanitizer.ADDRESS`, `UNDEFINED`, `THREAD`, `MEMORY`, `LEAK` |
+| `links(...)`, `linkFlags(...)` | Bibliotheken und Flags für den Linker |
+| `frameworks(...)` | Apple-Frameworks |
+| `arc` | nur Objective-C und Objective-C++; standardmäßig `true` |
+
+### Nach Art
+
+| Einstellung | Arten | Wirkung |
+| --- | --- | --- |
+| `args(...)`, `env(...)` | `bin`, `test` | was `run` und `test` an das Programm geben |
+| `rpath(...)`, `linkerScript`, `resources(...)` | `bin`, `sharedlib`, `test` | Link