In Entwicklung· Meilenstein M1 in Arbeit

Deine Daten, in der Form, die sie schon haben.

Selbst gehostet und Open Source, für Dashboards und Analysen. Tabellen bleiben Tabellen, Dokumente bleiben Dokumente, Graphen bleiben Graphen.

Auf GitHub verfolgen Zur Roadmap

SuchenKonzeptvorschau

Dashboards /

Bestellungen von Kunde C-1042

Beispieldaten

Bestellwert über die Zeitframe

Kunden, verbunden über ein Produktgraph

Bestelldokumentdocuments

_idObjectId
customerId"C-1042"
itemsArray(2)
sku"P-20"
priceDecimal128
shipping{ 1 }

Abdeckung der Felderdocuments

_id
customerId
createdAt
items
items[].sku
items[].price

Konzeptvorschau der geplanten Oberfläche, mit Beispieldaten. Kein Screenshot: Kalzit ist in Entwicklung.

Funktioniert mit

PostgreSQL
MySQL
MariaDB
SQL Server
SQLite
MongoDB
Neo4j
Memgraph
Prometheus
Elasticsearch

framedocumentsgraph

Eine Frage, drei Antworten

Was hat Kunde C-1042 bestellt?

Abfrage · SQLPostgreSQL

SELECT id, created_at, items, total
FROM orders
WHERE customer_id = 'C-1042'
ORDER BY created_at;

Ergebnis · frame
idtext	created_attimestamptz	itemsint4	totalnumeric
O-77	2026-09-02 10:14	3	129,90
O-84	2026-09-15 18:02	1	24,00
O-90	2026-10-03 08:47	2	89,50

Abfrage · MQLMongoDB

db.orders.find({ customerId: "C-1042" })

Dokument · documents

_id66f5a1c2e4b0…ObjectId
customerId"C-1042"string
createdAt2026-09-02T10:14:00ZDate
itemsArray(2)
- 0{ 3 }
  - sku"P-20"string
  - qty1int32
  - price49.90Decimal128
- 1{ 3 }
  - sku"P-31"string
  - qty2int32
  - price40.00Decimal128
shipping{ 1 }
- address{ 1 }
  - city"Leipzig"string

Schema-Ansicht
Pfad	Typen	In Dokumenten
_id	ObjectId	100 %
customerId	string	100 %
createdAt	Date	100 %
items	array 1–4	100 %
items[].sku	string	100 %
items[].price	Decimal128 92 %double 8 %	100 %
shipping.address.city	string	97 %
giftNote	string	3 %

Abfrage · CypherNeo4j

MATCH p = (:Customer {id: "C-1042"})-[:ORDERED]->(:Order)
      -[:CONTAINS]->(:Product)<-[:CONTAINS]-(:Order)
      <-[:ORDERED]-(:Customer)
RETURN p LIMIT 25

Pfad · graph

CustomerC-1042
ORDERED
OrderO-77
CONTAINS
ProductP-20
CONTAINS
OrderO-63
ORDERED
CustomerC-2210

Illustration mit Beispieldaten, kein Screenshot.

01Die Idee

Nichts wird heimlich flachgeklopft.

Viele Werkzeuge machen aus jedem Ergebnis eine Tabelle. Verschachtelte Dokumente werden zu Spalten, Graphen zu einer Liste von Knoten und einer Liste von Kanten, und die Struktur, wegen der du gekommen bist, ist weg. In Kalzit behält jedes Abfrageergebnis genau eine native Form: frame, documents oder graph. Panels geben an, welche Formen sie verstehen.

02Projektionen

Umwandlungen sind Schritte, die du siehst.

Manchmal willst du aus Dokumenten doch eine Zeitreihe. Dann legst du in der Abfrage einen Schritt „Projektion“ an, zum Beispiel $.metrics.cpu über $.ts. Der Schritt steht in der Abfrage, du kannst ihn rückgängig machen, und die ursprünglichen Dokumente bleiben verfügbar. Das Backend wandelt nie von selbst um.

documentsorders
Projektion$.metrics.cpu über $.ts
frameZeitreihe

Sichtbar in der Abfrage
Rückgängig zu machen
Original bleibt verfügbar

Auch Transformationen folgen der Form: Feld auswählen, Array entfalten oder nach Feldpfad gruppieren für Dokumente; Nachbarschaft erweitern, Subgraph filtern oder Knoten zusammenfassen für Graphen.

03Datenquellen

Übliche Quellen, jede in ihrer eigenen Form.

Relationale und Zeitreihen-Quellen antworten in Frames, MongoDB in Dokumenten, Neo4j und Memgraph in Graphen. Jede Quelle ist standardmäßig nur lesend: Der Server lehnt schreibende Abfragen ab, und Abfragen laufen immer über den Server, nie direkt vom Browser zur Datenbank.

Noch ist keine Datenquelle verfügbar. Die ersten kommen mit M1.

Geplante Datenquellen nach Meilenstein, aus dem Projektplan
Meilenstein	Quelle	Form
M1	PostgreSQL, TimescaleDB	frame
	MySQL, MariaDB	frame
	Microsoft SQL Server	frame
	SQLite	frame
	Prometheus, Mimir, Thanos, VictoriaMetrics	frame
M2	MongoDB	documents
	Elasticsearch, OpenSearch	documentsframe
	CSV, JSON, HTTP JSON	framedocuments
M3	Neo4j, Memgraph	graph
M5	InfluxDB	frame
	Loki	frame
	ClickHouse	frame
M6	Graphite	frame
	Redis	framedocuments
	Oracle	frame
	Tempo, Jaeger	graph

04Organisationen, Teams, Rollen

Über Zugriff entscheidet der Server, jedes Mal.

Eine Installation trägt mehrere Organisationen. Jede hat ihre eigenen Teams, Ordner, Dashboards und Datenquellen.

Rollen auf zwei Ebenen: Server-Admins betreiben die Installation. In einer Organisation sind Eigentümer, Admin, Bearbeiter und Betrachter feste Rollen, und du kannst eigene Rollen aus feingranularen Rechten bauen.
Kein Recht ohne Grundlage: Effektive Rechte sind die Vereinigung aus Rolle, Team-Rollen und direkten Freigaben. Ein Dialog „Warum darf ich das?“ zeigt, woher jedes Recht kommt. Standard ist „kein Zugriff“, und der letzte Eigentümer und der letzte Server-Admin lassen sich nicht entfernen.
Bei jeder Anfrage geprüft: Die Rechteprüfung läuft auf dem Server, für jede Anfrage und jede Ressource, nie nur in der Oberfläche.
Server-Einstellungen in Schichten: Umgebungsvariablen gehen vor der Konfigurationsdatei, die vor Einstellungen aus der Oberfläche geht. Netzwerk und TLS stehen nur in Datei oder Umgebung, damit dich ein Tippfehler in der Oberfläche nicht aussperrt.
Anmeldung: Lokale Konten mit Argon2id gehören zu M0. OIDC, LDAP und Active Directory sowie Zwei-Faktor-Anmeldung mit TOTP und Passkeys folgen mit M5.

Ausschnitt aus dem Rechte-Katalog

dashboards:read|write|delete|share
folders:read|write|permissions
datasources:query|read|write|permissions
analyses:read|write
data:export
teams:read|write|members
audit:read
settings:read|write

Rollensystem, Benutzerverwaltung und Einstellungen in der Oberfläche kommen mit M1. Konfigurationsdatei, Umgebungsvariablen und lokale Anmeldung gehören zu M0.

05Windows und Linux

Ein Binary, zwei gleichwertige Plattformen.

Kalzit ist ein einzelnes Rust-Binary mit eingebetteter Weboberfläche. Windows und Linux sind gleichberechtigt: Die CI baut und testet alles auf beiden. Geplante Release-Ziele sind Windows x64, Linux x64 und Linux arm64.

Windows

Konfiguration in %ProgramData%\Kalzit\kalzit.toml
Windows-Dienst und MSI-Installer mit M5
SQL Server mit M1, Anmeldung über Active Directory mit M5

Linux

Konfiguration in /etc/kalzit/kalzit.toml
deb- und rpm-Pakete mit systemd-Unit mit M5
Docker-Image mit M5

HTTPS eingebaut

TLS über rustls: derselbe Code auf beiden Systemen, kein OpenSSL zu installieren. Erneuerte Zertifikatsdateien werden ohne Neustart übernommen. ACME mit Let’s Encrypt folgt mit M5.

Kein Datenbankserver zum Start

Kalzit speichert seine eigenen Daten standardmäßig in SQLite. Größere Installationen nutzen PostgreSQL.

06Open Source

AGPL-3.0, selbst gehostet, keine Telemetrie.

Der vollständige Quellcode ist öffentlich, unter der GNU Affero General Public License 3.0. Kalzit läuft nur auf deinen eigenen Servern; eine Cloud-Variante gibt es nicht. Die Suche nach Updates ist aus, bis du sie einschaltest, und Telemetrie gibt es keine.

Von Grund auf neu geschrieben, als Clean-Room-Implementierung.
Eingebaute Datenquellen nutzen dieselbe Plugin-Schnittstelle wie externe Plugins (M4).
Plugins sind mit Ed25519 signiert; unsignierte Plugins brauchen die Freigabe eines Admins.
Plugin-SDK zuerst in Rust, danach in TypeScript und Go.

Lizenz lesen

07Stand

Früh dran, und ehrlich damit.

Kalzit entsteht öffentlich, Meilenstein für Meilenstein. Jeder Meilenstein endet mit grüner CI auf Windows und Linux und Doku zu jeder neuen Funktion.

Ganze Roadmap

08Der Name

Warum Kalzit

Kalzit ist das Mineral, das im Englischen „calcite“ heißt. Seine klarste Form, der Isländische Doppelspat, teilt jeden Lichtstrahl in zwei, sodass alles dahinter doppelt erscheint. Vielleicht haben die Wikinger ihn als Sonnenstein genutzt, um die Sonne hinter Wolken zu finden. Genau das soll Kalzit mit Daten tun: verborgene Struktur sichtbar machen.