Looker alternative

The Looker alternative with formal verification and recursive queries

LookML data tests check one query of at most 5,000 rows, and LookML has no recursive construct. SynaLemma proves its rules well-formed, safe and terminating, with native recursion.

SynaLemma

SynaLemma vs Looker: key differences

  1. Every rule proved before it runs

    A LookML data test checks one query of at most 5,000 rows. SynaLemma proves each rule well-formed, safe and terminating before any SQL runs. First-order assertions are checked over the whole table and return the rows that break them.

  2. The engine reasons, not the model

    LookML has no recursive construct; recursive SQL goes only in a hand-written derived table. In Synalog, recursion is part of the language: hierarchies and bills of materials are recursive rules, to a declared depth, verified to terminate. The engine compiles them to SQL on PostgreSQL, BigQuery, Databricks, Trino, Presto, DuckDB and SQLite.

  3. Sovereign by construction, not by contract

    Gemini in Looker is not available on customer-hosted instances. SynaLemma runs on-premises with the model you choose. The engine compiles the SQL, so a small open model is enough, with no per-token fees.

  4. Same rule, same SQL

    Gemini picks the fields and filters again for each question. In SynaLemma the agent writes a rule once and the engine compiles it, so the same rule always gives the same SQL. Every figure cites the rule it came from.

  5. One definition per term

    Available stock, a late delivery, a critical supplier: each is defined once, as a rule over your tables. Definitions build on each other, and people and agents share them.

  6. Every access scoped, every change on record

    The agent writes no SQL and acts only with the rights of the person asking; raw SQL is refused before it runs. Every change to a definition is a git commit with its author, reviewable and reversible.

Synalog

Example: a recursive query with assertions

A bill of materials up to 20 levels deep, with two assertions. The data contains a cycle; the engine reports it with the rows that break the assertion.

parts.l
# The bill of materials, read from the database.
Component(assembly:, part:, quantity:) :- bom(assembly:, part:, quantity:);

# A part is inside an assembly directly, or inside one of its parts.
@Recursive(Contains, 20);
@Assert(Contains,
      transitive: "∀ a b c, Contains a b → Contains b c → Contains a c",
      no_cycle:   "∀ a, ¬ Contains a a");
Contains(assembly:, part:) distinct :- Component(assembly:, part:);
Contains(assembly:, part:) distinct :-
  Contains(assembly:, part: sub),
  Component(assembly: sub, part:);
$ synalog parts.l verify
✓ Contains.transitive holds ✗ Contains.no_cycle is violated: ∀ a, ¬ Contains a a 2 counterexamples: +---------+ | a | +---------+ | "wheel" | | "hub" | +---------+ 2 rows
At a glance

SynaLemma vs Looker at a glance

SynaLemma vs Looker at a glance
CriterionSynaLemmaLooker
Semantic: one definition per term Definitions build on each other: each business term defined once, as a rule over your tables, reused by every person and agent Dimensions and measures defined once in LookML, reused across Explores
Reasoning: who computes joins, recursion, totals The engine, not the model: Synalog computes every join and recursion, to a declared depth, compiled to SQL Looker writes SQL from LookML; no recursive construct in LookML, recursive SQL only in a hand-written derived table
Verified: what is checked before a rule runs Every rule proved well-formed, safe and terminating; first-order assertions return the rows that break them LookML validator: syntax and references; data tests: one query, 5,000 rows at most
Deterministic: same rule, same SQL Never generated per question: SQL compiled by the engine from the rule; definitions reused and lockable Gemini picks fields and filters per question; Looker writes the SQL from them
Governed: access and change control The agent cannot bypass the layer: no SQL written, raw SQL refused, the asker's role only; every change a git commit Roles with permission and model sets; access filters on rows, access grants on fields; LookML in git
Language model The one you choose, a small open model is enough Gemini for Google Cloud features
Deployment On-premises, on your infrastructure Looker-hosted or customer-hosted; Gemini features only on Looker-hosted
Definitions written in Synalog, a logic language with a compiler LookML, a modelling language
Looker

Why teams look for a Looker alternative

  • No recursive construct in LookML

    Recursive SQL goes only in a hand-written derived table (derived tables).

  • The validator checks syntax and references

    Google's docs state that validation won't catch every issue (LookML validation).

  • Data tests are limited

    One query per test, at most 5,000 rows (test parameter).

  • Answers come from modelled Explores

    A data agent connects to up to five Explores; advanced analytics translates questions into Python code run on the query results (Conversational Analytics).

  • Gemini features, Looker-hosted only

    Gemini in Looker is not available on customer-hosted instances (Gemini in Looker).

FAQ

Looker alternative: FAQ

What is the best Looker alternative for AI agents?

SynaLemma. It compiles to SQL like Looker, and it defines each term once, reasons in a logic engine, proves its rules well-formed, safe and terminating, compiles the same rule to the same SQL and governs every change.

Can Looker handle recursive hierarchies?

Not with a LookML construct: recursive SQL goes only in a hand-written derived table. In Synalog, recursion is native, to a declared depth, and verified to terminate.

How is a Synalog assertion different from a LookML data test?

A LookML data test checks one query of at most 5,000 rows. A Synalog assertion is a first-order statement checked over the whole table, with counterexamples.

Can SynaLemma run with a local model?

Yes. A small open model on your own hardware is enough, because the engine compiles the SQL.

See it on your data

Bring a question your current stack can't answer.

In 30 minutes, we show SynaLemma answering it, with the rule behind the number and the checks it passed.