Dein erstes Programm.
In fünf Minuten.

Drei einfache Schritte.
Ein echtes Ergebnis.

Du musst am Anfang nicht jedes Zeichen auswendig lernen. Erkenne zuerst die Form: Eine typisierte Funktion empfängt Parameter, berechnet ein Ergebnis und wird aus `main()` aufgerufen.

Jetzt direkt ausprobieren.
Ohne lokale Installation.

Bearbeite den Zelyra-Code im Editor und klicke auf »Ausführen«. Dein Code wird in Echtzeit vom echten Zelyra-Compiler ausgeführt.

Die sechs Bausteine.
Lesbar. Explizit. Strukturiert.

Jede Zelyra-Datei basiert auf wenigen, verständlichen Bausteinen ohne versteckte Magie:

Auf deinem Computer installieren.
Wähle dein Betriebssystem.

Wähle einen Installationsweg. Veröffentlichte Binärdateien gibt es derzeit für Linux x86_64 und Windows x86_64; macOS benötigt einen Build aus dem Quellcode.

git clone https://github.com/sf1976/zelyra.git
cd zelyra
./install.sh

cd zelyra
git pull --ff-only
./install.sh

zelyra --version
zelyra doctor

curl -fsSL https://raw.githubusercontent.com/sf1976/zelyra/main/install.sh | bash -s -- --release v0.3.0

git clone https://github.com/sf1976/zelyra.git
cd zelyra
./install.sh

zelyra --version
zelyra doctor

irm https://raw.githubusercontent.com/sf1976/zelyra/main/install.ps1 | iex

git clone https://github.com/sf1976/zelyra.git
cd zelyra
.\install.ps1

zelyra --version
zelyra doctor

git clone https://github.com/sf1976/zelyra.git
cd zelyra
docker compose -f docker-compose.mariadb.yml up -d --build

docker compose exec app zelyra --version
docker compose exec app zelyra run examples/fibonacci.zyl

Die ideale Projektstruktur.
Standardisiert. Klar. Wartbar.

Jedes mit `zelyra new` erstellte Projekt folgt einem klaren Standardaufbau. Quellcode, Datenbankmodelle, Lokalisierungskataloge, Umgebungskonfigurationen und Container-Dateien haben einen festen, sicheren Platz:

mein-projekt/
├── main.zyl                  # Zelyra-Quelldatei
├── zelyra.toml               # Projektkonfiguration
├── .env                      # lokale Konfiguration
├── .env.example              # Beispiel ohne Geheimnisse
├── .gitignore                # Git-Ausschlüsse
├── Dockerfile
├── docker-compose.mariadb.yml
├── locales/
│   ├── de.json
│   └── en.json
└── machine-management-demo.sql

Zelyra aktuell halten.
Integrierter 1-Befehl Updater.

Der Befehl `zelyra update` aktualisiert die installierte CLI. Deine erzeugte Anwendung liegt in einem separaten Projektverzeichnis. Sichere das Projekt und prüfe die Release-Hinweise, bevor du Compiler-Versionen wechselst.

# 1. Prüfen, ob eine neue Version verfügbar ist:
zelyra update --check

# 2. Automatisch auf die neueste Version aktualisieren:
zelyra update

# 3. Neue Version und Systemgesundheit verifizieren:
zelyra --version
zelyra doctor

cd zelyra && git pull origin main && ./install.sh

Die wichtigsten Befehle.
Auf einen Blick.

Das sind die am häufigsten genutzten Zelyra-Befehle für Entwicklung, Formatierung, Ausführung und Datenbank-Setup:

Offizielles Syntax-Highlighting.
Für VS Code, Cursor, Windsurf, JetBrains, Zed, Helix, Emacs, Notepad++ & Vim.

Zelyra liefert offizielle Syntax-Pakete, TextMate-Grammatiken und Major Modes für 8+ Entwicklungsumgebungen. Jede Karte enthält direkte Installations- und Verwendungsanleitungen:

# VS Code CLI:
code --install-extension zelyra.vsix

# Cursor AI IDE:
cursor --install-extension zelyra.vsix

# Windsurf AI IDE:
windsurf --install-extension zelyra.vsix

mkdir -p ~/.vscode/extensions/zelyra/syntaxes && \
curl -s https://demo.siedelmann.com/editors/package.json -o ~/.vscode/extensions/zelyra/package.json && \
curl -s https://demo.siedelmann.com/editors/language-configuration.json -o ~/.vscode/extensions/zelyra/language-configuration.json && \
curl -s https://demo.siedelmann.com/editors/zelyra.tmLanguage.json -o ~/.vscode/extensions/zelyra/syntaxes/zelyra.tmLanguage.json

mkdir -p ~/.config/JetBrains/TextMate/zelyra/syntaxes && \
curl -s https://demo.siedelmann.com/editors/zelyra.tmLanguage.json -o ~/.config/JetBrains/TextMate/zelyra/syntaxes/zelyra.tmLanguage.json

mkdir -p ~/.config/zed/grammars && \
curl -s https://demo.siedelmann.com/editors/zelyra.tmLanguage.json -o ~/.config/zed/grammars/zelyra.tmLanguage.json

# Append to ~/.config/helix/languages.toml
mkdir -p ~/.config/helix
cat << 'EOF' >> ~/.config/helix/languages.toml

[[language]]
name = "zelyra"
scope = "source.zelyra"
injection-regex = "zelyra|zyl"
file-types = ["zyl", "zelyra"]
comment-token = "//"
block-comment-tokens = { start = "/*", end = "*/" }
indent = { tab-width = 4, unit = "    " }
roots = ["zelyra.toml", ".git"]

[language.auto-pairs]
'(' = ')'
'{' = '}'
'[' = ']'
'"' = '"'
'`' = '`'
EOF

# 1. Download zelyra-mode.el
mkdir -p ~/.emacs.d/lisp
curl -s https://demo.siedelmann.com/editors/zelyra-mode.el -o ~/.emacs.d/lisp/zelyra-mode.el

# 2. Add to ~/.emacs.d/init.el:
(add-to-list 'load-path "~/.emacs.d/lisp/")
(require 'zelyra-mode)

# Linux
mkdir -p ~/.config/sublime-text/Packages/User
curl -s https://demo.siedelmann.com/editors/zelyra.sublime-syntax -o ~/.config/sublime-text/Packages/User/zelyra.sublime-syntax

# macOS
mkdir -p ~/Library/Application\ Support/Sublime\ Text/Packages/User
curl -s https://demo.siedelmann.com/editors/zelyra.sublime-syntax -o ~/Library/Application\ Support/Sublime\ Text/Packages/User/zelyra.sublime-syntax

mkdir -p ~/.config/nvim/syntax ~/.config/nvim/ftdetect
curl -s https://demo.siedelmann.com/editors/zelyra.vim -o ~/.config/nvim/syntax/zelyra.vim
echo 'au BufRead,BufNewFile *.zyl setfiletype zelyra' > ~/.config/nvim/ftdetect/zelyra.vim

mkdir -p ~/.nano && \
curl -s https://demo.siedelmann.com/editors/zelyra.nanorc -o ~/.nano/zelyra.nanorc && \
grep -qxF 'include "~/.nano/zelyra.nanorc"' ~/.nanorc 2>/dev/null || echo 'include "~/.nano/zelyra.nanorc"' >> ~/.nanorc

Tab-Vervollständigung.
Für Bash, Zsh & Fish.

Aktiviere sofortige Befehls- und Dateivervollständigung für die Zelyra CLI-Toolchain in deiner bevorzugten Shell:

Continuous Integration.
Automatisierte Invariantenprüfung & GitHub Actions.

Continuous Integration kann ausgewählte Zelyra-Prüfungen bei Änderungen automatisch ausführen. Sie beweist nicht allgemein die Korrektheit eines Projekts. Dieser Abschnitt stellt einen einfachen Ablauf vor und zeigt, wie du ihn an dein Projekt anpasst.

Was habe ich konkret davon? (Der praktische Nutzen im Alltag)

Continuous Integration ist kein Werkzeug nur für Großkonzerne – es spart jedem Entwickler täglich Zeit, Nerven und peinliche Fehler:

Funktionsweise: Der 4-stufige Ablauf der CI-Pipeline

Sobald du Code pushst oder einen Pull Request erstellst, durchläuft GitHub Actions vollautomatisch diese vier Prüfphasen:

# .github/workflows/zelyra-ci.yml
# Checks Zelyra source with the published v0.3.0 compiler.
name: Zelyra CI

on:
  push:
    branches: [main, master]
  pull_request:
    branches: [main, master]

jobs:
  check:
    name: Check Zelyra v0.3.0 sources
    runs-on: ubuntu-latest

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Install published Zelyra v0.3.0
        shell: bash
        run: |
          git clone --depth 1 --branch v0.3.0 https://github.com/sf1976/zelyra.git "$RUNNER_TEMP/zelyra-source"
          "$RUNNER_TEMP/zelyra-source/install.sh" --release v0.3.0 --root "$RUNNER_TEMP/zelyra-install" --no-path
          echo "$RUNNER_TEMP/zelyra-install/bin" >> "$GITHUB_PATH"

      - name: Verify installed version
        run: zelyra --version

      - name: Format and check each Zelyra source file
        shell: bash
        run: |
          mapfile -d '' zelyra_files < <(find . -type f -name '*.zyl' -not -path './.git/*' -print0)
          if ((${#zelyra_files[@]} == 0)); then
            echo "No .zyl source files found."
            exit 1
          fi
          for file in "${zelyra_files[@]}"; do
            zelyra fmt --check "$file"
            zelyra check "$file"
          done

# Zelyra v0.3.0 has no built-in test runner; add application-specific tests separately.

Dieser Workflow prüft Formatierung und unterstützte Syntax einzeln pro Datei. `zelyra check` beweist nicht die Fehlerfreiheit einer Anwendung; v0.3.0 enthält außerdem keinen Befehl `zelyra test`. Ergänze Laufzeit- und Integrationstests mit den Testwerkzeugen deiner Anwendung.

Häufige Fragen.
Schnelle Lösungen.

Sollte bei der Installation oder Ausführung etwas klemmen, findest du hier die bewährten Lösungen: