Your first program.
In five minutes.

Three simple steps.
One verified result.

You do not need to memorize every keyword immediately. Notice the shape: a typed function receives arguments, computes a return value, and is executed from `main()`.

Try it right now.
Zero setup required.

Edit the Zelyra code below and click »Run Code«. The code is compiled and executed in real-time by the Zelyra compiler engine.

The six core elements.
Readable. Explicit. Structured.

Every Zelyra file builds upon clear, unambiguous building blocks that eliminate surprises and enforce predictable runtime behavior:

Install on your computer.
Choose your operating system.

Choose an installation route. Published release binaries currently target Linux x86_64 and Windows x86_64; macOS uses a source build.

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

The anatomy of a Zelyra project.
Standardized. Clean. Maintainable.

Every Zelyra project generated via `zelyra new` follows a strict, zero-overhead layout where source code, schema models, localized translation catalogs, environment secrets, and container configurations have predictable, secure places:

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

Keep your toolchain up to date.
Built-in 1-command updater.

The `zelyra update` command updates the installed CLI. Your generated application is a separate project directory; back it up and check release notes before changing compiler versions.

# 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

The essential commands.
At a single glance.

Here are the most frequently used Zelyra commands for creating, checking, running, and managing applications:

Official Syntax Highlighting.
For VS Code, Windsurf, JetBrains, Zed, Helix, Emacs, Notepad++ & Vim.

Zelyra provides official syntax packages, TextMate grammars, and major modes for 8+ development environments. Every card contains direct installation and usage instructions:

# 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 completion for your shell.
Bash, Zsh & Fish support.

Enable instant command and file autocompletion for the Zelyra CLI toolchain in your favorite terminal shell:

Continuous Integration.
Automated Invariant Proofs & GitHub Actions.

Continuous Integration can run selected Zelyra checks automatically when code changes. It does not prove a project correct in general. This section introduces a basic workflow and how to adapt it to your project.

What are the real-world benefits? (Why every developer should use CI)

Continuous Integration is not just a tool for large enterprises—it protects solo developers and teams from stressful bugs:

How the GitHub Actions Pipeline Works (Step-by-Step)

When you push code or open a pull request, GitHub Actions executes this deterministic verification sequence:

# .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.

This workflow checks formatting and the supported syntax one file at a time. `zelyra check` is not a proof that an application is correct, and v0.3.0 does not include a `zelyra test` command. Add runtime and integration tests using your application’s own test tools.

Common hurdles.
Instant solutions.

If you encounter an issue during installation or execution, here are the most common solutions: