ZELYRA
Zelyra 0.1.50 · in active development

From idea
to your own application.

With Zelyra you define data models, business rules and web pages in a clear, statically typed language. Built in Rust.

Release v0.1.50 GitHub ★ Star
🦀 Rust 2024
🐬 MariaDB Native
⚖️ Apache-2.0
customer.zyl ✓ checked in 4ms
01table customers {
02id: Id primary auto
03name: String(100) required
04email: Email?
05}
schema types forms API
One single model Schema, types, validation & SQL
Compile-time Safety Caught before reaching production
01 / the idea

Describe once.
Reuse everywhere.

Zelyra connects data models, types, validation, SQL and interfaces. From a clear description, proven building blocks for your application emerge step by step.

Understand the principle
01 Foundation
Data Model

The central schema defining tables, constraints and types.

table customers { ... }
02 Logic
Types & Rules

Nominal types and Design by Contract enforce valid states.

type UserId = Id
03 Web
Web & Forms

Routes and forms generated with schema-aware validation.

page "/customers" { ... }
04 SQL
Checked SQL

Direct SQL power verified against your schema at compile time.

query { select id, name }
02 / why zelyra
01

Clearly typed.
Checked early.

Explicit types, immutable values and visible optional data help catch mistakes during checks.

name: String?
match name {
02

The model takes
center stage.

One schema can become the foundation for domain types, SQL, forms, APIs and CRUD.

tableformAPI
03

Start small.
Grow safely.

Begin with a small program and expand it step by step into a full web application.

Open learning path
03 / THE MANIFESTO & MEANING · DIGITAL SOVEREIGNTY

What Zelyra means:
A dedication to digital sovereignty & architectural craftsmanship.

In an era where modern software is increasingly trapped in opaque dependencies, fragile abstractions, and closed overseas cloud monopolies, Zelyra represents the enduring spirit of true digital self-determination and inventive independence. Where others preach "Move fast and break things", we build for things that are meant to last: mathematically verifiable correctness, uncompromising resource discipline, and software that serves its creator rather than foreign platforms.

Z
Zero-Tolerance for Flaws

Mathematically verifiable correctness via Design by Contract. Zero null-pointer exceptions, zero unhandled branches, zero hoping for luck.

E
Excellence & Sovereignty

Complete technological independence from closed vendor ecosystems. Your code, your schema, your absolute freedom.

L
Logical Transparency

Code that explicitly states what it expects and delivers. Explicit types, readable schemas, and verifiable contracts instead of hidden magic.

Y
Yield & Productivity

Maximum architectural leverage: data models, relational databases, validation, and web UI converge seamlessly into a unified architecture.

R
Resilience (Forged in Rust)

Built to industrial-grade standards. Resilient under heavy load, minimal footprint, and built to endure for decades.

A
Autonomy (Data Sovereignty)

True data and infrastructure sovereignty. Local execution, database freedom, zero hidden telemetry, full control.

The Zelyra Principle: Software craftsmanship over black-box dependency. Built for developers creating lasting value.
🛡️ Digital Craftsmanship & Sovereignty
⚡ Vision & Roadmap

Development note: The principles and architecture outlined here describe the definitive goal and vision of Zelyra, not yet its full current completion. The language and ecosystem are actively being developed milestone by milestone towards this standard.

04 / getting started

The best way to learn
is by doing.

Four accessible steps guide you from your first program to a database-backed web application.

your first lesson

Say what you mean.

Zelyra code describes clearly what values a function expects and what result it delivers.

View example
fibonacci.zyl
fn fibonacci(n: Int) -> Int {
    if n <= 1 {
        return n
    }

    return fibonacci(n - 1) +
           fibonacci(n - 2)
}
→ 55
05 / try it out

Read. Modify.
Understand.

Here is a small Zelyra page. Change the code in the editor or the parameter in the route bar and watch how it turns into a safe HTML response in real time.

Quick test:
Good to know & 100% interactive The web server is built-in. Type directly into the code box or the GET path above to simulate instant compilation and rendering.
hello_web.zyl ✏️ editable ▶ Open in Playground
GET http://localhost:3000/hello/
zelyra serve :3000
HTTP/1.1 200 OK ⚡ rendered in 0.8ms (auto-escaped)
06 / language comparison

Where Zelyra fits:
Safety without complexity.

Full side-by-side comparison
vs. TypeScript Nominal Types & Checked Schema

TypeScript checks shapes only superficially. Zelyra embeds relational constraints, table schemas, and distinct nominal types directly into compiler verification.

vs. PHP & Python Zero Null Crashes & High Speed

No sudden runtime exceptions, no heavy ORM abstraction layers. Statically verified contracts and instant compiled speed in Rust with built-in HTTP server.

vs. Rust Tailored for Web & Database

All the memory and type safety of Rust, but without lifetime and borrow-checker friction for everyday web applications, database CRUD, and forms.

07 / installation & quickstart

Ready in minutes.
Run locally or with Docker.

Choose the installation that fits your workflow. Zero external runtime dependencies required.

Option 01 · Standalone
Native CLI Installation

Clones and builds the Rust binary directly for maximum local performance.

$ git clone https://github.com/sf1976/zelyra.git
$ cd zelyra && ./install.sh
Next command: zelyra check fibonacci.zyl
Option 02 · Full Stack
Docker Compose & MariaDB

Instantly provisions a containerized environment including MariaDB and hot reload.

$ zelyra new my-app --mariadb
$ cd my-app && docker compose up -d
Next command: zelyra db setup main.zyl
open source & community

Build your next project
with true independence.

Explore the handbook, inspect the open-source compiler on GitHub or start with our 5-minute interactive tutorial.

Z