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 vs Looker: key differences
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
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.
# 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:); SynaLemma vs Looker at a glance
| Criterion | SynaLemma | Looker |
|---|---|---|
| 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 |
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).
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.
Sources
- Google Cloud: What is LookML?
- Google Cloud: Validating LookML
- Google Cloud: the test parameter (LookML data tests)
- Google Cloud: join types in LookML
- Google Cloud: derived tables in Looker
- Google Cloud: Conversational Analytics in Looker
- Google Cloud: Gemini in Looker
- Google Cloud: Looker (Google Cloud core) overview
- Google Cloud: Looker roles
- Google Cloud: version control and deploying changes
- Google Cloud: access control and permission management
- Synalog on GitHub (Apache-2.0)
Checked against each product's public documentation on the review date. To report an error: contact@synalinks.com.
Other comparisons
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.