<?xml version="1.0" encoding="UTF-8"?>
<!-- generator="FeedCreator 1.8" -->
<?xml-stylesheet href="https://doc.seolizer.de/lib/exe/css.php?s=feed" type="text/css"?>
<rdf:RDF
    xmlns="http://purl.org/rss/1.0/"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
    xmlns:dc="http://purl.org/dc/elements/1.1/">
    <channel rdf:about="https://doc.seolizer.de/feed.php">
        <title>SEOLizer Dokumentation - lyx_-_programmiersprache</title>
        <description></description>
        <link>https://doc.seolizer.de/</link>
        <image rdf:resource="https://doc.seolizer.de/_media/wiki:dokuwiki.svg" />
       <dc:date>2026-04-08T11:59:16+00:00</dc:date>
        <items>
            <rdf:Seq>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:abi-calling-conventions?rev=1775549202&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:arrays-datensammlungen?rev=1775547560&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:arrays-maps?rev=1775547682&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:attributes-pragmas?rev=1775545511&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:compiler-parameter?rev=1775542191&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:das-energy-aware-programmiermodell?rev=1774716507&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:datentypen?rev=1775549279&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:dedingungen?rev=1775545528&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:do-178c?rev=1775548781&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:erste-schritte?rev=1775547943&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:exception-handling?rev=1775544381&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:ffi?rev=1775545496&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:generics-traits?rev=1775545634&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:lyx-compiler-selbst-kompilieren?rev=1775546898&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:memory-management?rev=1775542713&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:oop?rev=1775549044&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:pattern-matching?rev=1775549090&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:pointer-inlining?rev=1775545552&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:rekursion?rev=1775548670&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:schleifen?rev=1775541640&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:syntax?rev=1775541656&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:units?rev=1775541671&amp;do=diff"/>
            </rdf:Seq>
        </items>
    </channel>
    <image rdf:about="https://doc.seolizer.de/_media/wiki:dokuwiki.svg">
        <title>SEOLizer Dokumentation</title>
        <link>https://doc.seolizer.de/</link>
        <url>https://doc.seolizer.de/_media/wiki:dokuwiki.svg</url>
    </image>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:abi-calling-conventions?rev=1775549202&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T08:06:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – ABI &amp; Calling Conventions</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:abi-calling-conventions?rev=1775549202&amp;do=diff</link>
        <description>Lyx – ABI &amp; Calling Conventions

Die ABI (Application Binary Interface) definiert, wie Funktionen auf Binärebene kommunizieren. Lyx folgt den Standard-Konventionen der Zielplattform, um Kompatibilität mit System-Aufrufen (Syscalls) und externen C-Bibliotheken zu gewährleisten.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:arrays-datensammlungen?rev=1775547560&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T07:39:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Arrays &amp; Datensammlungen</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:arrays-datensammlungen?rev=1775547560&amp;do=diff</link>
        <description>Lyx – Arrays &amp; Datensammlungen

In Lyx v0.9.0 gibt es spezialisierte Container-Typen, die zwischen deterministischer Safety (Stack) und hoher Flexibilität (Heap/SIMD) unterscheiden.

1) Statische Arrays (Fixed-Size)

Für Systeme mit hohen Sicherheitsanforderungen (</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:arrays-maps?rev=1775547682&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T07:41:22+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Arrays &amp; Maps</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:arrays-maps?rev=1775547682&amp;do=diff</link>
        <description>Lyx – Arrays &amp; Maps

Lyx bietet spezialisierte Container-Typen, die zwischen deterministischer Sicherheit (Stack) und hoher Flexibilität (Heap/SIMD) unterscheiden.

1) Statische Arrays (Fixed-Size / Stack)

Für Systeme mit hohen Sicherheitsanforderungen (</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:attributes-pragmas?rev=1775545511&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T07:05:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Attribute &amp; Pragmas (@-Referenz)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:attributes-pragmas?rev=1775545511&amp;do=diff</link>
        <description>Lyx – Attribute &amp; Pragmas (@-Referenz)

In Lyx werden Metadaten und Compiler-Anweisungen über Attribute (auch Pragmas genannt) gesteuert. Sie beginnen immer mit einem @-Zeichen und können auf Units, Funktionen oder Variablen angewendet werden.

1. Sicherheits- &amp; Integritäts-Attribute</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:compiler-parameter?rev=1775542191&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T06:09:51+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx Compiler – CLI Referenz</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:compiler-parameter?rev=1775542191&amp;do=diff</link>
        <description>Lyx Compiler – CLI Referenz

Der Lyx-Compiler (lyxc) ist ein moderner Cross-Compiler für Linux, Windows, macOS und Embedded-Systeme. Er wird über die Kommandozeile gesteuert:
lyxc &lt;Eingabedatei&gt; [Optionen]

1) Basis-Operationen
 Parameter  Beschreibung</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:das-energy-aware-programmiermodell?rev=1774716507&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-03-28T16:48:27+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Energy-Aware Programmiermodell</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:das-energy-aware-programmiermodell?rev=1774716507&amp;do=diff</link>
        <description>Lyx – Energy-Aware Programmiermodell

In modernen Systemen ist „Performance pro Watt“ oft wichtiger als reine Rechenleistung. Lyx führt ein Modell ein, bei dem der Programmierer den Energie-Fußabdruck direkt im Quellcode oder über Compiler-Flags steuern kann.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:datentypen?rev=1775549279&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T08:07:59+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Datentypen</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:datentypen?rev=1775549279&amp;do=diff</link>
        <description>Lyx – Datentypen

Diese Seite gibt einen technischen Überblick über die aktuell unterstützten Datentypen in Lyx sowie deren Implementierungsstatus im Compiler (Stand v0.9.0).

Aktuell unterstützte Datentypen

1. Ganzzahl-Typen (signiert)
 Typ  Bits</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:dedingungen?rev=1775545528&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T07:05:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Bedingungen (if / else)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:dedingungen?rev=1775545528&amp;do=diff</link>
        <description>Lyx – Bedingungen (if / else)

Bedingungen steuern den Kontrollfluss in Lyx. Sie erlauben es, Codeblöcke nur dann auszuführen, wenn eine bestimmte logische Voraussetzung erfüllt ist.

1. Grundlegende Syntax

Eine if-Bedingung erwartet einen Ausdruck, der zu einem</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:do-178c?rev=1775548781&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T07:59:41+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>DO-178C Compliance in Lyx</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:do-178c?rev=1775548781&amp;do=diff</link>
        <description>DO-178C Compliance in Lyx

Die DO-178C ist der primäre Standard der Luftfahrtbehörden (EASA, FAA) zur Zertifizierung von Software in fliegenden Systemen. Lyx wurde entwickelt, um die Einhaltung dieses Standards durch native Sprachfeatures und Compiler-Garantien zu unterstützen.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:erste-schritte?rev=1775547943&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T07:45:43+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Erste Schritte (Quick Start)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:erste-schritte?rev=1775547943&amp;do=diff</link>
        <description>Lyx – Erste Schritte (Quick Start)

Willkommen bei Lyx! Diese Anleitung hilft dir dabei, deine Entwicklungsumgebung einzurichten und dein erstes sicherheitskritisches Programm zu kompilieren.

1) Installation

Lyx ist als autarkes Binary (lyxc) konzipiert. Es benötigt keine externen C-Standardbibliotheken, da es ein eigenes Backend für x86_64, ARM64 und RISC-V besitzt.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:exception-handling?rev=1775544381&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T06:46:21+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Fehlerbehandlung (Exception Handling)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:exception-handling?rev=1775544381&amp;do=diff</link>
        <description>Lyx – Fehlerbehandlung (Exception Handling)

Lyx bietet zwei primäre Mechanismen zum Umgang mit Fehlern: Das klassische Exception-Handling für allgemeine Anwendungen und das Result-Pattern für deterministische, sicherheitskritische Systeme.

1. Natives Try-Catch-System</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:ffi?rev=1775545496&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T07:04:56+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Foreign Function Interface (FFI)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:ffi?rev=1775545496&amp;do=diff</link>
        <description>Lyx – Foreign Function Interface (FFI)

Das Foreign Function Interface (FFI) erlaubt es Lyx-Programmen, Funktionen aufzurufen, die in anderen Programmiersprachen (primär C) geschrieben wurden, und Daten mit ihnen auszutauschen. Dies ist notwendig für die Nutzung von System-APIs (POSIX, Win32) oder spezialisierten Mathematik-Bibliotheken.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:generics-traits?rev=1775545634&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T07:07:14+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Generics &amp; Traits</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:generics-traits?rev=1775545634&amp;do=diff</link>
        <description>Lyx – Generics &amp; Traits

Generics ermöglichen es, Funktionen und Strukturen zu schreiben, die mit verschiedenen Datentypen arbeiten, ohne den Code mehrfach kopieren zu müssen. Traits definieren dabei die Anforderungen (Interfaces), die diese Typen erfüllen müssen.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:lyx-compiler-selbst-kompilieren?rev=1775546898&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T07:28:18+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Compiler selbst kompilieren</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:lyx-compiler-selbst-kompilieren?rev=1775546898&amp;do=diff</link>
        <description>Lyx – Compiler selbst kompilieren

Da der Lyx-Compiler in Free Pascal (FPC) implementiert ist, kann er leicht aus den Quellen erstellt werden. Dies ist notwendig, wenn Sie Änderungen am Compiler-Kern vornehmen oder Lyx auf einer neuen Plattform (Bootstrapping) installieren möchten.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:memory-management?rev=1775542713&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T06:18:33+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Memory Management</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:memory-management?rev=1775542713&amp;do=diff</link>
        <description>Lyx – Memory Management

Lyx bietet volle Kontrolle über den Speicher. Es verzichtet bewusst auf einen Garbage Collector (GC), um Vorhersagbarkeit (Determinismus) und minimale Latenz zu garantieren. Das Speichermodell basiert auf Stack-Allokation, manuellem Heap-Management und Sicherheits-Checks für kritische Systeme.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:oop?rev=1775549044&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T08:04:04+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Objektorientierte Programmierung (OOP)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:oop?rev=1775549044&amp;do=diff</link>
        <description>Lyx – Objektorientierte Programmierung (OOP)

Lyx kombiniert die Performance von Systemprogrammiersprachen mit der Ergonomie moderner OOP-Sprachen. Dabei wird strikt zwischen leichtgewichtigen Strukturen und mächtigen Klassen unterschieden.

1) Structs (Value-Types)</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:pattern-matching?rev=1775549090&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T08:04:50+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Pattern Matching (match)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:pattern-matching?rev=1775549090&amp;do=diff</link>
        <description>Lyx – Pattern Matching (match)

Das match-Statement ist eines der mächtigsten Kontrollfluss-Elemente in Lyx. Es erlaubt den Vergleich eines Wertes gegen eine Reihe von Mustern (Patterns). Im Gegensatz zu switch in C oder Java ist match in Lyx typsicher</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:pointer-inlining?rev=1775545552&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T07:05:52+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Low-Level: Pointer &amp; Inlining</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:pointer-inlining?rev=1775545552&amp;do=diff</link>
        <description>Lyx – Low-Level: Pointer &amp; Inlining

Obwohl Lyx durch Funktionen wie Null-Safety und Range-Checks schützt, benötigt die Systemprogrammierung (Treiber, Kernel, Echtzeit-Regler) direkten Zugriff auf Speicheradressen und präzise Kontrolle über den generierten Maschinencode.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:rekursion?rev=1775548670&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T07:57:50+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Rekursion</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:rekursion?rev=1775548670&amp;do=diff</link>
        <description>Lyx – Rekursion

Lyx unterstützt rekursive Funktionsaufrufe unter Einhaltung der plattformspezifischen ABIs. Da Lyx auf deterministische Laufzeiten optimiert ist, bietet der Compiler spezielle Werkzeuge zur Überwachung des Stack-Verbrauchs.

1) Grundlagen &amp; Safety-Constraints</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:schleifen?rev=1775541640&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T06:00:40+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Schleifen (Loops)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:schleifen?rev=1775541640&amp;do=diff</link>
        <description>Lyx – Schleifen (Loops)

Lyx bietet verschiedene Mechanismen zur Iteration. Die Sprache legt hierbei besonderen Wert auf die Unterscheidung zwischen Standard-Programmierung und sicherheitskritischer Programmierung.

	&quot; Wichtiger Hinweis zur Zertifizierung:</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:syntax?rev=1775541656&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T06:00:56+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Syntax</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:syntax?rev=1775541656&amp;do=diff</link>
        <description>Lyx – Syntax

Diese Seite bietet eine kompakte, technische Übersicht über die Syntax und Semantik der Sprache Lyx (Stand v0.5.7).

1) Lexikalische Regeln

Kommentare

Zeilenkommentar: 

//

 bis Zeilenende\
Blockkommentar: 

/* ... */

 (nicht verschachtelt)</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:units?rev=1775541671&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T06:01:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Units &amp; Standard Library</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:units?rev=1775541671&amp;do=diff</link>
        <description>Lyx – Units &amp; Standard Library

Lyx bietet eine umfangreiche Standardbibliothek (std), die modular aufgebaut ist. Jede Unit muss explizit importiert werden, sofern es sich nicht um einen Compiler-Builtin handelt.

1) Kern-Units (Basis-System)

Diese Units bilden das Fundament für jedes Lyx-Programm und kapseln die direkten Syscalls der Zielplattform.</description>
    </item>
</rdf:RDF>
