Zeretis is a deterministic symbolic math engine — not an AI, not an approximation, not a chatbot. We built it because we were frustrated with tools that guess, hallucinate, or require expensive GPU clusters just to compute a derivative. Math has correct answers. We wanted a tool that finds them exactly, shows its working, and respects your privacy while doing it.
AI-based math tools — including large language models — produce plausible-looking answers that are sometimes wrong, with no reliable way to tell when. They approximate, they guess, they hallucinate steps. For learning, that's actively harmful: a confidently-stated wrong answer is worse than no answer at all.
The professional tools that actually work — Mathematica, Maple, MATLAB's symbolic toolbox — are expensive, complex to install, and require institutional licences. A student or teacher who just needs to check a derivative or verify an integral shouldn't need to navigate all of that.
Zeretis sits between those extremes. It uses the same class of symbolic computation algorithm that powers the professional tools, but delivered as a browser-based product with a natural language interface, a clean API, and a pricing model that starts free and scales to enterprise.
An approximate answer presented confidently is worse than a disclaimer. Zeretis uses symbolic computation — which means it either gives you an exact result or tells you it can't find one. It doesn't approximate silently. It doesn't round unless you ask. √2 stays as √2, π stays as π, and fractions stay as fractions. That's not a limitation — it's the point.
A math tool that only gives you the answer is not a learning tool — it's a shortcut machine. Zeretis shows every step in a solution, with each rule or property labelled. That's what makes it useful for students checking their reasoning, teachers demonstrating methods, and engineers auditing derivations. We designed it this way from the beginning, not as an afterthought.
We don't collect queries because we don't need to — the solver doesn't learn from them. We don't log inputs because there's no business reason to. We don't require an account for the free tier because your email address has nothing to do with solving a quadratic. Privacy at Zeretis is the result of architectural decisions, not a policy document we wrote to comply with GDPR.
The most powerful math tools are inaccessible to most people not because the math is too hard, but because the interface is. LaTeX is a typesetting language, not a thinking tool. Zeretis accepts plain English, standard notation, and LaTeX — interchangeably, in the same session. You describe the problem the way you think about it, and the solver handles the rest. Lowering that barrier is one of the most impactful things we can do.
"Math has correct answers. We built a tool that finds them — and shows you exactly how."The Zeretis team
Zeretis is built on symbolic computation — the same mathematical discipline that underpins professional tools like Mathematica and Maple. Where an LLM predicts the next token based on statistical patterns in training data, a symbolic solver applies algebraic rules exactly — factoring, differentiating, integrating using provable mathematical identities.
This means results are deterministic: the same expression always gives the same result, on any device, at any time. There is no randomness, no sampling temperature, no "creative" interpretation of your problem. The solver either computes the exact result or reports that it cannot find a closed form.
It also means Zeretis requires no GPU, no model weights, no inference infrastructure. The computation runs efficiently on standard CPUs — which is why our energy footprint is a fraction of LLM-based tools, and why results appear almost instantly.
Every query to a large language model requires GPU inference — which is energy-intensive at scale. Symbolic computation is fundamentally different: it's an algorithmic process that runs on commodity hardware, uses a tiny fraction of the energy, and produces perfectly cacheable results.
This isn't a vague claim — it's measurable. The Zeretis solver is a compiled Rust program that runs in approximately 30 microseconds on a standard laptop. A typical LLM inference call takes hundreds of milliseconds on a dedicated GPU. That's a difference of four to five orders of magnitude — 99.9999% less energy for the same mathematical result. At scale, that efficiency compounds enormously.
We think that matters. Symbolic computation is an underused tool in a world that's reaching for LLMs as a default solution to problems they aren't well-suited to solve. For exact mathematical computation, there's a better way — and it happens to be the greener one too.
The things we won't compromise on — ever.
Queries are processed and discarded. We have nothing to sell because we don't store it.
The solver only does math — a technical constraint, not a content filter that can be bypassed.
10 problems a month, forever. Access to exact math tools shouldn't require a credit card.
We're funded by subscriptions. Our only incentive is to make the product genuinely useful.
CPU-only, no GPU inference, perfectly cacheable. Symbolic computation is the greener choice.
The core solver is live and working. The web interface, the API, the subscription model, and the natural language input layer are all running. But there's a lot more we want to build.
We're working on expanding the solver's problem coverage — more ODE types, partial differential equations, complex analysis, and graph theory are all on the roadmap. We're also improving the natural language parser so it handles more conversational, ambiguous input even more reliably.
For educators, we're planning classroom-specific features: the ability to generate problem sets from a template, compare multiple student solutions side by side, and export worked solutions to common formats used in education. For engineers, we're expanding the API with batch processing, webhook results, and tighter JSON schemas for downstream integration.
If you have a specific use case you'd like to discuss, or a problem type the solver doesn't yet handle, get in touch. We read everything and respond to most things.
If we can't compute it exactly, we say so. We won't add numerical approximation that obscures the line between exact and estimated.
Power users and first-time users should both feel at home. Natural language lowers the floor; the API and LaTeX support raise the ceiling.
New features that require data collection will be opt-in, clearly signposted, and never a condition of core functionality.
We'd rather have something real in your hands with rough edges than a perfect product that doesn't exist yet. The blog is where we document what we learn.