// für die Nerds

Was tatsächlich unter der Haube läuft

Ab hier kein Marketing-Geschwafel mehr. Das ist die echte Architektur – die Crates, die Datenstrukturen, die Designentscheidungen – des SQLly-GPUI-Clients, der aktiv entwickelt wird und von dem jeder Screenshot auf dieser Seite stammt.

// das Frontend

Eine GPU-gerenderte native UI, kein Webview

Das Fenster, das du vor dir hast, ist weder Electron noch eine Browser-Engine mit nativ aussehender Haut.

SQLly - GPUI-Editor
SQLly-Editor, nativ über GPUI gerendert, zeigt die Schlüsselwortvervollständigung von IntelliSense

Jeder Pixel hier - Textlayout, das Autovervollständigungs-Popup, die Syntaxhervorhebung - wird von GPUIs eigenem GPU-beschleunigtem Renderer gezeichnet.

🖼️
gpui ✓ funktional

Derselbe Rendering-Ansatz wie Zed

Der Client von SQLly baut auf GPUI auf, dem Rust-UI-Framework, das für den Zed-Editor geschrieben wurde. Es ist ein GPU-beschleunigtes Hybrid-Toolkit aus retained und immediate mode – kein DOM, keine AppKit-Views darunter, einfach Rust, das direkt auf die GPU zeichnet.

🧩
sqlly-datatable ✓ funktional

Das Ergebnisraster ist ein eigenes Crate

Statt die Grid-Virtualisierung inline von Hand zu bauen, nutzt das Ergebnisraster ein eigenes, veröffentlichtes Crate - sqlly-datatable - das Virtualisierung, Auswahl, Sortierung und Filterung als eigenständige Komponente abdeckt.

🖥️
eine Codebasis, drei Betriebssysteme ✓ funktional

macOS, Windows und Linux aus einem einzigen Quellbaum

Der GPUI-Client deckt alle drei Desktop-Plattformen aus derselben Rust-Codebasis ab, mit Packaging pro Betriebssystem: ein .app Bundle auf macOS (nur Apple Silicon), ein .desktop Eintrag auf Linux und ein natives .exe auf Windows.

// Open Source, läuft in deinem Browser

Versuch sqlly-datatable - das tatsächliche Ergebnisraster, als WebAssembly

Das Ergebnisraster ist eine eigene Open-Source-Crate, und seine Beispiel-App wird auf GPUIs Web-Backend zu WebAssembly kompiliert - gezeichnet von demselben GPU-Renderer, den die Desktop-App nutzt, keine Screenshots, sondern die echte Komponente, laufend in einer WebGPU-Canvas. Wir hosten diesen Live-Build jetzt in der Dokumentation, wo er nur lädt, wenn du ihn öffnest, und wieder entladen wird, sobald du ihn verlässt, sodass das WebAssembly-Payload nie untätig im Hintergrund liegt.

Benötigt einen WebGPU-fähigen Browser (Chrome/Edge 113+ oder ein aktuelles Safari/Firefox). Läuft komplett auf deinem Rechner – nichts wird irgendwohin gesendet.

// SQL parsen, aber richtig

Zwei Lexer, dialektbewusste Parser und ein span-getreuer Baum

SQL ist keine einzige Sprache. T-SQL, Postgres, MySQL, Oracle, SQLite, ClickHouse und DuckDB sind sich uneinig bei Quoting, Kommentaren und der halben Syntax - und Redis ist überhaupt kein SQL - daher behandelt der Anfang der Pipeline den Dialekt als Parameter erster Klasse, nicht als Nebensache.

🔤
sqlly-sqllex ✓ funktional

Ein über Dialekttabellen gesteuerter Lexer

Tokenisierungsregeln - Anführungsstile, Kommentarsyntax, Operatorsätze - stecken in Tabellen pro Dialekt statt in fest codierten Verzweigungen, sodass das Hinzufügen oder Korrigieren eines Dialekts nicht bedeutet, den Lexer zu forken.

🌳
sqlly-sqlparse ✓ funktional

Fehlertolerante Parser, pro Dialekt

Jeder unterstützte Dialekt erhält seinen eigenen fehlertoleranten Parser, der positionsgenau zum Quelltext bleibt – das heißt, der geparste Baum behält die exakten Quellpositionen, sodass IntelliSense und Diagnosen auf genau das richtige Zeichen zeigen können, selbst wenn die umgebende Abfrage fehlerhaft ist.

🧭
sqlly-tokenizer ✓ funktional

Ein zweiter, schnellerer Scanner – absichtlich

Ein separater Single-Pass-Tokenizer treibt das Dateisystem-Overlay-Objektmodell an (siehe unten). Er ist bewusst einfacher und schneller als der komplette Lexer/Parser-Stack, weil er über jede Datei in einem Schema-as-Code-Repository läuft, nicht nur über die Abfrage, die Sie gerade bearbeiten.

📡
sqlly-lsp ✓ funktional

Ein echter T-SQL Language Server

Auf dem Parser-Stack sitzt eine echte LSP-Implementierung über JSON-RPC/stdio – Hover, Diagnosen, semantische Tokens und Autovervollständigung – sodass dieselbe Intelligenz, die den Editor antreibt, von jedem LSP-kompatiblen Client genutzt werden kann.

// die Schema-Modell-Engine

Zwei Collectoren, eine atomare Momentaufnahme

Das ist der Teil, der den Trick „lokale Dateien schlagen die Live-Datenbank“ im DBA-Handbuch wirklich funktionieren lässt - und schnell bleibt.

// conceptual shape, not literal source
generation += 1;
let db_task   = spawn(collect_from_database(generation));
let fs_task   = spawn(collect_from_filesystem(generation));
let (db, fs)  = join(db_task, fs_task).await;
let merged    = merge_by_provenance(db, fs);  // newer mtime/hash wins
snapshot.swap(merged);  // atomic - readers never see a half-built model
🔀
parallele Sammlung ✓ funktional

Datenbank und Dateisystem, gleichzeitig gesammelt

sqlly-modelengine führt einen Datenbankkollektor und einen Dateisystemkollektor parallel aus, jeweils mit einem Generationszähler markiert, und führt sie dann über eine Barrieren-Zusammenführung wieder zusammen, bevor irgendetwas Downstream das Ergebnis sieht.

⏳
Veralterung nach Zeitstempel + Hash ✓ funktional

Frische wird gemessen, nicht angenommen

Der Merge vergleicht Änderungszeitpunkte und Inhalts-Hashes zwischen dem, was die Live-Datenbank meldet, und dem, was auf der Festplatte liegt, sodass eine lokale Datei die Datenbank nur überschreibt, wenn sie wirklich neuer ist – nicht nur, weil sie da ist.

📸
generation-staged Snapshots ✓ funktional

Leser sehen nie ein halb fertiges Modell

Das zusammengeführte Modell wird pro Generation als ein einziger atomarer Snapshot eingespielt. IntelliSense und Validierung lesen immer ein vollständiges, in sich konsistentes Modell – entweder die vorherige Generation oder die neue, nie einen gerade laufenden Teilumbau.

🌫️
unvollständige Bereiche ✓ funktional

Vertrauen wird als Daten verfolgt, nicht als Vermutung

Wo das Modell nicht vollständig validiert werden kann – eine grobe DDL-Skizze, eine Migration mitten in der Bearbeitung – kennzeichnet die Engine diesen Bereich mit expliziten Provenance und Fidelity Metadaten und durchläuft für die Vervollständigung einen eigenen Validierungspfad mit zwei Gültigkeitsbereichen, statt eine Vermutung stillschweigend zur Tatsache zu erklären.

// der KI-Stack auf dem Gerät

Lokale Modellinferenz, mit der Cloud als optionaler Fallback

Die KI-Story ist wirklich mehrstufig – von komplett lokaler Inferenz bis zu einem Cloud-Anbieter, den du ausdrücklich selbst wählst. Hier steht, was heute im GPUI-Client schon real ist, klar gekennzeichnet.

⚡
FIM-Vervollständigung ◐ in Bearbeitung

Fill-in-the-Middle-Autovervollständigung

Die FIM-Vervollständigung im Code-Stil ist dafür ausgelegt, mit einem kleinen lokalen Modell (Qwen2.5-Coder-Klasse) für Inline-Vorschläge während der Eingabe zu laufen. Die Prompt-Darstellung, der Modell-/Token-Katalog und die Einstellungen sind vollständig portiert und mit Unit-Tests abgedeckt; der Streaming-Transport für die Generierung ist das Teilstück, das noch angebunden wird.

🗣️
KI-Chat-Panel ◐ in Bearbeitung

Ein Assistenten-Panel mit echter Architektur

Das KI-Panel ist eine portierte, strukturierte Chat-Oberfläche – kein Platzhalter –, um Fragen zu deinem Schema zu stellen und generiertes SQL zurückzubekommen. Panel und Zustand sind echt; die Anbieter-Anbindung dahinter wird gerade verdrahtet.

🦙
ollama ◐ in Bearbeitung

Bring dein eigenes lokales Modell über Ollama mit

Fährst du deine Modelle schon über Ollama, hängt sich SQLly direkt daran an, für Schema-Q&A, Embeddings und Suche. Die Health-/Installations-Zustandsmaschine ist portiert und steuert die UI; die Prozessverwaltungsschicht, die ollama wird gerade fertiggestellt.

🧭
sqlly-mlx ◐ in Bearbeitung

Ein MLX-Sidecar für Apple Silicon

Lokale Inferenz auf Apple Silicon läuft über einen kleinen externen MLX-Sidecar-Prozess, mit dem SQLly über HTTP spricht - so bleibt die schwere ML-Laufzeit aus dem Hauptprozess der App raus. Die Werttypen und das Health-Reporting sind da; das Starten und Verwalten des Sidecars ist in Arbeit.

🗃️
lokaler Vektorspeicher ○ geplant

Vektorsuche auf dem Gerät (LanceDB)

Der Plan ist ein vollständig lokaler Vektorspeicher für Schema-/Embedding-Suche über LanceDB. Im Moment ist dieses Crate ein beabsichtigter Stub – jeder Aufruf liefert einen klaren, ehrlichen Fehler, statt stillschweigend nichts zu tun –, während der Rest der Pipeline darum herum fertig ist.

☁️
Cloud-Fallback ◐ in Bearbeitung

Cloud-Anbieter, freiwillig und ausdrücklich

Wenn du über die Modelle auf dem Gerät hinausgehen willst, stehen die Cloud-Anbieter-Auswahl (OpenRouter, OpenAI, Claude) und ihr Einstellungsbereich bereit – nichts verlässt deinen Rechner, es sei denn, du lenkst es selbst dorthin. Der HTTP-Transport hinter der Auswahl wird gerade angebunden.

Warum auf Unvollendetes hinweisen? Denn die Alternative wäre eine Funktionsseite, die stillschweigend nicht mehr stimmt, sobald jemand den Quelltext liest. Die Modell-Auswahl ist zum Beispiel in der alten Swift-App weiter als heute in GPUI – das sagen wir dir lieber, als dass du es selbst merkst.
// alles Weitere in der Engine

Der Rest des Rust-Arbeitsbereichs

Die Engine ist in fokussierte Crates gegliedert statt ein Monolith zu sein — die meisten lassen sich headless erreichen über sqlly-cli zum Skripten oder Testen ganz ohne UI.

CrateWas es besitzt
sqlly-coreVerbindungsprofile, Befehls- und Ereignismodelle, Sitzungen, App-Einstellungen, Snapshots zur Absturzwiederherstellung.
sqlly-enginesDie nativen Treiber hinter einem Transport-Trait: SQL Server über TDS (auf Tiberius basierend), PostgreSQL, MySQL/MariaDB, SQLite, libSQL/Turso über Hrana, DuckDB im Prozess, ClickHouse über HTTP, Oracle über den Instant Client und Redis über RESP.
sqlly-queryAbfrageausführung/-streaming, IntelliSense-Vervollständigungslogik, Abfrageverlauf, Tokenizer-Verknüpfung.
sqlly-metadataObjekt-Explorer und Katalog-Metadatenmodelle.
sqlly-scriptingBezeichner-Quoting, Skripterstellung und durchsuchbarer Skriptvorlagen-Katalog.
sqlly-plansParsing von Ausführungsplänen (ShowPlan XML) und Planwarnungen.
sqlly-adminBackup/Wiederherstellung, Aktivitätsmonitor, Tabellenbearbeitung, Abfragespeicher, erweiterte Ereignisse, Import/Export, Schemavergleich und Designer-SQL-Generierung.
sqlly-securitySQL- und Entra-Authentifizierungsanbieter, Secret-Store-Abstraktionen, Sicherheitskatalog-SQL.
sqlly-catalog„Objektkarten“, hybride Volltext- + Vektorsuche über das Schema und Invalidierung des KI-Caches.
sqlly-testkitSQL Server-Container und Fixture-/Golden-File-Test-Hilfen, die in der eigenen Testsuite des Workspaces verwendet werden.
📝
Vorlagen ✓ funktional

Ein echter Skriptvorlagen-Katalog

Das Vorlagensystem verwendet dieselbe <name,type,default> Platzhalter-Syntax SSMS Vorlagen verwenden - absichtlich vertraut statt eine neue DSL, die man von Grund auf lernen müsste.

🔬
split_statements ✓ funktional

Batch-Skripte, ein Statement nach dem anderen

Der Lexer stellt einen Anweisungs-Splitter bereit, den der Mutation-Review-Pfad nutzt, sodass sich ein Skript mit mehreren Anweisungen Anweisung für Anweisung durchdenken und auf Sicherheit prüfen lässt — statt als ein undurchsichtiger Klumpen.

// getestet, nicht nur schnell

Die Leistungsangaben werden von der Testsuite untermauert

✅
✓ funktional

Ein Latenz-Budget-Test für die Autovervollständigung

Die IntelliSense-Crate enthält einen Test, der sicherstellt, dass zwischengespeicherte Vervollständigungen innerhalb eines expliziten Latenzbudgets bleiben – Performance-Rückgänge auf dem Vervollständigungspfad lassen CI fehlschlagen, statt dass ein Nutzer sie erst Monate später bemerkt.

✅
✓ funktional

Integrationstests mit echten Unterprozessen

Über Unit-Tests hinaus wird die CLI-Engine mit Integrationstests mit echten Unterprozessen getestet, die tatsächliche Umgebungsvariablen setzen und auf korrelierte Protokolle prüfen – abgedeckt werden Ping/Antwort-Korrelation, Erkennung unbeantworteter Anfragen und das Kürzen von Protokollen bei kontrolliertem Herunterfahren.

✅
✓ funktional

Golden-File-Fixtures gegen einen echten SQL Server

sqlly-testkit startet einen echten SQL Server-Container für Integrationstests, sodass die Abfrage- und Metadatenebenen gegen eine echte Engine getestet werden und nicht nur gegen gemockte Antworten.

Das ist die Tour.

Wenn dir hier etwas aufgefallen ist, das vom Quelltext abgedriftet ist - der Code entwickelt sich schnell weiter - sag uns Bescheid. Lieber korrigieren wir die Seite, als sie stillschweigend veralten zu lassen.