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.

Zelyra source files use explicit language constructs. The compiler checks implemented syntax and types; this does not eliminate runtime surprises:

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 v1.2.40

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.

The `zelyra new` command creates files for the selected template. Review the generated project and keep credentials in your local environment configuration:

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://www.zelyra.eu/editors/package.json -o ~/.vscode/extensions/zelyra/package.json && \
curl -s https://www.zelyra.eu/editors/language-configuration.json -o ~/.vscode/extensions/zelyra/language-configuration.json && \
curl -s https://www.zelyra.eu/editors/zelyra.tmLanguage.json -o ~/.vscode/extensions/zelyra/syntaxes/zelyra.tmLanguage.json

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

mkdir -p ~/.config/zed/grammars && \
curl -s https://www.zelyra.eu/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://www.zelyra.eu/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://www.zelyra.eu/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://www.zelyra.eu/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://www.zelyra.eu/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://www.zelyra.eu/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 supported syntax one file at a time. `zelyra check` does not prove that an application is correct. 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: