Download the Giolit Trading Risk Verifier free trial.
Prove your trading algo and its risk limits hold on every price move, fill and cancel — or see the exact sequence of events that breaks them.
2 · Get the download
Unlock the Trade Verifier trial
One short form — the download appears instantly, for every trial you picked.
Trial details
What's in the Giolit Trading Risk Verifier trial
Trade verifier trial: 1000 runs, 50 days
Every run your assumptions allow
Backtests check the runs someone thought of — this trial checks all of them: get the giolit-trade-verifier-1.0.0-trial.tar.gz package (5 MB) with the trade-verify command and C++ SDK, 22 tutorial examples, 9 strategy templates, CI configurations, and the full benchmark — 44 specifications, 180 rules with known answers and every result — plus the Brochure, three tutorials and the Reference Manual. Run trade-verify 01_position_limit.gts on Ubuntu 24.04 — when a rule can break, you see the exact sequence of events, step by step, with a replay file for your developers — see what the trade verifier checks.
The costly failures are the runs nobody tested: two orders through one limit, a router that overfills across venues, a late fill after a cancel, a leg rejected after the other filled, a kill switch that reaches one venue. Each needs a particular order of messages — which a backtest almost never contains. The verifier explores every one, and answers each rule with PROVEN for any number of orders, or BROKEN with the exact sequence of events.
Your strategy as you wrote it — from C++, Python or Java, or as one-line rules that read like a risk policy.
$ trade-verify --headroom desk.gts
$ trade-verify strategy.gts --report=bundle --issued-to="Example Broking Pvt Ltd"
$ trade-verify desk.gts --conform=dropcopy-2026-10-09.fix
- Risk limits for any client algo — check your pre-trade controls against an algorithm that may send any order or cancel at any moment, so brokers can vet client algos without seeing their code.
- Several exchanges, legs and threads — per-exchange limits, messages arriving in any order, multi-leg orders, and risk checks that run on their own thread.
- Exact maths — strategies written with floating point are checked exactly as your code computes them, rounding included.
- Check live trading logs — replay yesterday's trading log against your rules: every message that should be impossible, every order the rules would not send.
- Templates — market maker, TWAP, VWAP, POV, pairs, lead–lag, delta hedge, smart order router and pre-trade gateway, each with its standard constraints proved.
Real outputs
Example results from the trial
Every rule ends PROVEN — with the proof, headroom and a certificate — or VIOLATED with a concrete run you can replay, typically 3 to 15 events long. Below are three real results that ship in the trial's results/ folder, each with its console output, results.json and reproduce.sh.
$ trade-verify 02_position_limit_fixed.gts
PROVEN position_limit
[for any number of orders]
ALL CONSTRAINTS PROVEN in 0.25 s
PROVEN
Position limit — proved for any number of orders
Counting open orders closes the gap the unfixed version leaves open (01: VIOLATED in 6 events).
$ trade-verify 14_smart_order_router.gts
VIOLATED no_overfill run, 5 events
4 Fill O2 100 (BSE) remaining=50
5 PartialFill O1 97 (NSE) remaining=-47
VIOLATED kill_stops_all run, 2 events
VIOLATED
Smart order router — overfill on NSE + BSE
Both venues fill the same quantity; the kill switch cancels one venue only. The fixed router is proved.
$ trade-verify simple_pmm.gts
import: SimplePMM, 2 handlers (Python)
VIOLATED one_quote_per_side 2 events
PROVEN quote_size, passive_bid
VIOLATED
Hummingbot PMM — unmodified open-source code
Refreshing quotes before cancels are acknowledged leaves two working quotes per side.
Trial reports are watermarked and unsigned. Rerun any of these yourself: every benchmark ships with its reproduce.sh.
What's inside
Trade trial package contents
Backtests check the runs someone thought of — this package checks every run, with the evidence to show for it.
- trade-verify command — verify with
trade-verify spec.gts, add--headroom,--report=DIR,--traces=DIR,--conform=LOG,--templates. - 22 tutorial examples — each bug next to its fix: position limits, kill switch, late fills, VWAP, Avellaneda–Stoikov, smart order router, leg hedger, pairs.
- 180-rule benchmark — 44 specifications with known answers, including 5 open-source strategies from unmodified code, and every result.
- Docs + SDK — Brochure, three tutorials, Reference Manual, README and License Terms; the C++ SDK with examples; GitHub Actions and GitLab CI configurations.
System requirements
Runs on Ubuntu 24.04 Linux x86-64
All engines are Giolit's own — no solver to install, no cloud, no upload. Your strategies and parameters never leave your machine.
- Ubuntu 24.04 LTS x86-64 or newer (one Linux computer per trial).
libllvm18,libclang-cpp18,libclang-common-18-dev,libc6-dev,libssl3.- LuaLaTeX + qpdf for PDF reports;
python3or a JDK to import Python or Java strategies.
Install
Install and verify in minutes
When a rule can break you get the run event by event, as text, JSON and a FIX 4.4 log — fit for daily use straight from the command line.
$ tar xzf giolit-trade-verifier-1.0.0-trial.tar.gz
$ cd giolit-trade-verifier-1.0.0-trial/code && ./install.sh
$ cd ~/.local/giolit-trade-verifier/share/giolit/examples
$ trade-verify 01_position_limit.gts
$ trade-verify --headroom 02_position_limit_fixed.gts
$ trade-verify --license
trade-verify --license shows runs and days left without using a run.
What it checks
Questions the trial answers
Every rule you state is decided against every interleaving the exchange protocol and your assumptions allow.
- Can a limit ever be broken? — PROVEN for any number of orders, or VIOLATED with the shortest run, also as FIX 4.4 messages.
- Can the strategy do its job? — feasible targets come back FEASIBLE with a run, or INFEASIBLE, proved; execution cost gets proved bounds.
- How close does it come? — headroom and the Resilience Score for every proven limit; conformance replay for production logs. Everything it checks.
Expert details+
- Model: the FIX 4.4 order life cycle with exchange options (late fills, exchange cancels, split fill reports); several exchanges and symbols; risk checks on separate threads; floating-point strategies checked exactly as computed.
- Outputs: signed PDF certificate in the licensed edition (watermarked report in the trial); every failing sequence as text, JSON, FIX 4.4 and a CSV price path; SHA-256 hashes for integrity; JSON, JUnit and comparison with a previous release.
- CI: exit codes 0 all proven, 1 violated, 2 undecided or bounded, 3 usage or input error, 4 no license;
--timeout,--constraint,--json,--junit,--baseline; C++ SDK.
Meet the Giolit Trading Risk Verifier
Explore proof for algorithmic trading: risk controls and strategies verified on every run, with the breaking run as a FIX log.
Compare
Which trial is right for me?
| C Verifier | SVA Verifier | Trade Verifier | |
|---|---|---|---|
| Built for | Firmware, embedded and systems engineers | RTL designers and verification engineers (ASIC / FPGA) | Brokers, prop and HFT desks, algo vendors, risk and compliance teams |
| You give it | C source files — multi-file projects, threads | SystemVerilog RTL with SVA assertions | Trading strategies in C++, Python or Java, or plain rules |
| It proves | Free of run-time errors: overflow, out-of-bounds, null and dangling pointers, leaks, data races | Every assertion holds for all inputs and start states; covers reachable; safety margins | Position limits, order caps, price bands, kill switches and no-overfill rules hold on every sequence of orders and fills |
| You get back | PDF certificate or report with the failing input, JSON, SARIF | Certificate with safety margins, or the failing cycle as a VCD waveform and replay testbench | Signed certificate with safety margins, or the breaking sequence as a replayable FIX 4.4 log |
| First command | v7 file.c | sva-verify --reset=rst design.sv | trade-verify strategy.gts |
| Trial | C Verifier free trialor read about the C program verifier | SVA Verifier free trialor read about the SystemVerilog assertion verifier | Trade Verifier free trialor read about the trading risk verifier |
After you download
From download to first proof
- 1
Install in minutes
Extract the archive and run ./install.sh on Ubuntu 24.04. No solver to install, no account, no network needed.
- 2
Run the worked examples
Each trial ships with tutorial examples — every bug next to its fix — and a benchmark with known answers you can rerun.
- 3
Check your own code
Point it at your project, design or strategy. Questions? Our team helps trial users get to a first result.
FAQ
Free trial questions
Are the Giolit trials free?
+
Yes. Each trial is free for 1000 runs within 50 days on one Linux computer. No credit card, and nothing to cancel — the trial simply expires.
Which trial do I need?
+
C software such as firmware, drivers and multi-file C projects: the Program Verifier. RTL hardware with SystemVerilog assertions: the SVA Verifier. Algorithmic trading strategies and pre-trade risk controls: the Trading Risk Verifier. You can request several trials with one form.
What are the system requirements?
+
Ubuntu 24.04 LTS x86-64 or newer with LLVM/Clang 18 libraries, libc6-dev and libssl3. LuaLaTeX and qpdf are needed only for PDF reports; JSON and text output need nothing extra.
How do I install a trial?
+
Extract the archive, run ./install.sh, then run the first example: v7 file.c, sva-verify --reset=rst design.sv or trade-verify 01_position_limit.gts. Each package includes a tutorial and worked examples.
Is my code uploaded anywhere?
+
No. Every verifier runs entirely on your own machine, with Giolit's own engines and no cloud service. Your source code, RTL or trading strategy never leaves it.
What does each verifier produce?
+
A verdict for every check — proven, or the exact case that breaks it — with reports: PDF, JSON and SARIF for C; waveforms and replay testbenches for SVA; replayable FIX 4.4 logs for trading. Trial reports are watermarked.
Can I use the verifiers in CI?
+
Yes. Each tool returns exit codes for proven, violated and undecided results and writes machine-readable output, so it can gate merges and releases.
What happens when the trial ends?
+
After 1000 runs or 50 days the tool stops running new checks; anything you generated stays yours. Contact Giolit Labs for a production or CI licence. The --license option shows runs and days left at any time without using a run.
Ready for production or CI?
Continued use after the trial needs a licence. Talk to us about licences for your team and build pipeline, verification services and training.