Klar typisiert.
Früh geprüft.
Explizite Typen, unveränderliche Werte und sichtbare optionale Daten helfen, Fehler schon beim Prüfen zu finden.
name: String?
match name {
match name {
Zelyra 0.1.45 · in aktiver Entwicklung
Von der Idee
zur eigenen Anwendung.
Mit Zelyra beschreibst du Daten, Regeln und Webseiten in einer klaren, statisch typisierten Sprache.
customer.zyl✓ checked
01table customers {
02id: Id primary auto
03name: String(100) required
04email: Email?
05}
schema→types→forms→API
01ein Modellfür deine Anwendung
✓Fehler früh erkennenbevor sie die Produktion erreichen
Modell → Prüfung → Anwendung
01 / die idee
Einmal beschreiben.
Mehrfach nutzen.
Zelyra verbindet Datenmodell, Typen, Validierung, SQL und Oberfläche. Aus einer klaren Beschreibung entstehen Schritt für Schritt geprüfte Bausteine für deine Anwendung.
Das Prinzip verstehen →01DatenmodellDie gemeinsame Grundlage
02Typen & LogikRegeln klar ausdrücken
03Web & FormulareDirekt nutzbar
04Geprüftes SQLNachvollziehbar umgesetzt
02 / warum zelyra
Klar typisiert.
Das Modell
steht im Mittelpunkt.
Ein Schema kann zur Grundlage für fachliche Typen, SQL, Formulare, APIs und CRUD werden.
table→form→API
Klein anfangen.
Sicher wachsen.
Beginne mit einem kleinen Programm und erweitere es Schritt für Schritt zur Webanwendung.
Lernpfad öffnen →03 / dein einstieg
Eine Sprache lernt man
am besten im Tun.
Vier überschaubare Schritte führen dich vom ersten Programm zur datenbankgestützten Webanwendung.
deine erste lektion
Sag, was du meinst.
Zelyra-Code beschreibt klar, welche Werte eine Funktion erwartet und welches Ergebnis sie liefert.
Beispiel ansehen →fibonacci.zyl
fn fibonacci(n: Int) -> Int {
if n <= 1 {
return n
}
return fibonacci(n - 1) +
fibonacci(n - 2)
}04 / ausprobieren
Lesen. Verändern.
Verstehen.
Hier siehst du eine kleine Zelyra-Seite. Ändere den Namen in der Route und beobachte, wie daraus eine sichere HTML-Antwort entsteht.
✦
Gut zu wissenDer Webserver ist eingebaut. Für den Einstieg brauchst du kein Apache.
hello_web.zyl
page "/hello/{name}" {
html {
<h1>Hello, {name}!</h1>
}
}05 / die bausteine
Zelyra verstehen,
Schritt für Schritt.
Die Beispiele folgen dem natürlichen Weg einer Anwendung: erst Werte und Regeln, dann Daten, Oberfläche und geprüfte Schnittstellen.
lektion 01 / grundlagen
Variablen sagen, was sie sind.
Zelyra setzt auf Klarheit. Werte sind standardmäßig unveränderlich; Veränderlichkeit wird ausdrücklich markiert.
- Typen können explizit angegeben werden
- Funktionen haben typisierte Ein- und Ausgaben
- Der Compiler findet Widersprüche früh
basics.zyl
name = "Anna"
age: Int = 25
mutable counter = 0
counter = counter + 1
fn add(a: Int, b: Int) -> Int {
return a + b
}↳Wenn sich etwas ändern darf, steht es sichtbar im Code.
lektion 02 / sichere werte
Option und Result statt Überraschungen.
Normale Werte sind nicht null. Optionale Werte werden mit ? gekennzeichnet und per Pattern Matching behandelt.
- Some(value) für einen vorhandenen Wert
- None für „nicht vorhanden“
- Result für Erfolg oder Fehler
option_match.zyl
name: String?
match name {
Some(value) => print(value)
None => print("Unknown")
}↳Jeder Fall ist sichtbar — und damit testbar.
lektion 03 / fachtypen
Gleiche Basis. Andere Bedeutung.
Nominale Typen schützen deine Geschäftslogik. Eine UserId und eine OrderId sind nicht austauschbar, auch wenn beide auf Id basieren.
- Fachbegriffe werden Teil des Typsystems
- Falsche Zuordnungen werden abgelehnt
- Regeln bleiben direkt am Modell
domain_types.zyl
type UserId = Id
type OrderId = Id
fn load_order(id: OrderId) {
// UserId ist hier kein Ersatz
}↳Der Typ erinnert dich an die fachliche Bedeutung.
lektion 04 / schleifen
Kontrolle bleibt lesbar.
Schleifen können mit break, continue und überprüfbaren Invarianten beschrieben werden.
- Expliziter Kontrollfluss
- Optionale Schleifeninvarianten
- Prüfstatus über zelyra verify
loop_control.zyl
mutable current = 3
while current > 0
invariant { current >= 0 }
{
current = current - 1
}↳Nur PROVEN ist ein Beweis; sonst bleibt die Runtime wachsam.
06 / aus daten wird produkt
Ein Schema ist
kein Endpunkt.
In Zelyra wird die Datenbank zur Ausgangsbasis für Validierung, Formulare, SQL und Web-Logik.
schema → formular
Regeln nur einmal pflegen.
Pflichtfelder und maximale Längen aus dem Schema können in einem Formular wiederverwendet werden.
- unbekannte Felder werden abgelehnt
- Pflichtfelder werden automatisch geprüft
- E-Mail-Adressen erhalten passende Validierung
customer_form.zyl
table customers {
id: Id primary auto
name: String(100) required
email: Email?
}
form CustomerCreate -> customers {
fields { name email }
}sql → typisiert
Native Kontrolle, geprüfte Grenzen.
Eigenes SQL bleibt möglich. Zelyra prüft Schema, Spalten, Parameter und Ergebnisse — ohne dich in eine ORM-Schicht zu zwingen.
- MariaDB, SQLite und PostgreSQL
- benannte Parameter
- Capability
Database
native_sql.zyl
capability Database
query customers {
select id, name, email
where active = true
order by name
}↳Freie SQL-Idee, aber klar markierte Datenbankfähigkeit.
07 / web & schnittstellen
Vom Pfad zur
echten Anwendung.
Der Web Core bringt Routing, HTML, Query-Strings und Requests zusammen. APIs können daraus typisierte Verträge machen.
web core
Eine Seite ist eine Route.
Mit einem eingebauten Server kannst du direkt loslegen. Der Pfadparameter wird standardmäßig HTML-escaped.
- GET-Routen
- Pfadparameter
- Query-String und HTML-Responses
hello_web.zyl
page "/hello/{name}" {
html {
<html>
<h1>Hello, {name}!</h1>
</html>
}
}typed api
Verträge für Clients.
API-Deklarationen können Routen und Typen prüfen, strukturierte Fehler liefern und OpenAPI- sowie TypeScript-Ausgaben erzeugen.
- typisierte Arrays und Records
- Result-Fehlerzuordnung
zelyra docfür OpenAPI/TypeScript
api.zyl
api GET "/customers" -> Customer[] {
auth "user"
return customers
}↳Eine Deklaration kann Dokumentation und Client-Code antreiben.
05 / dein nächster schritt
Vom ersten Programm
zum eigenen Projekt.
Starte klein, prüfe jeden Schritt und erweitere dein Beispiel erst dann zur eigenen Anwendung.
Hello, Zelyra
Installieren, Fibonacci ausführen, den Check-Befehl kennenlernen.
Ein Modell
Eine Tabelle beschreiben, Fachtypen anlegen und ein kleines Record lesen.
Eine Seite
Route, Parameter und HTML-Response mit dem eingebauten Server verbinden.
Ein Formular
Schemaabhängige Felder validieren und die Regeln bewusst sichtbar machen.
Eine API
Typen, Authentifizierung und strukturierte Fehler zu einer Schnittstelle formen.
Verify & wachsen
Contracts, SQL, CRUD und Datenbank-Capabilities nach Bedarf ergänzen.
Ohne Docker
git clone https://github.com/sf1976/zelyra.git && cd zelyra && ./install.shDanach kannst du direkt ein Beispiel prüfen und ausführen.Mit Docker und MariaDB
zelyra new meine-app --mariadb && cd meine-app && cp .env.example .env && docker compose --env-file .env -f docker-compose.mariadb.yml up -d --buildDanach: zelyra db setup main.zylZ
06 / dein nächster schritt
Baue dein
erstes Projekt.
Beginne mit einem kleinen Beispiel, lerne die Grundlagen kennen und entwickle daraus Schritt für Schritt deine eigene Anwendung.
Zum GitHub-Repository ↗