Trilocore is a browser-based, all-in-one smart-contract workbench. You do not need to install any desktop applications to get started.
We are currently developing a native desktop CLI and application for deeper OS-level integrations. Stay tuned for updates on our Windows, macOS, and Linux installers.
BEVM is a visual workbench for the EVM. You load a contract, inspect how it works, hunt for vulnerabilities with detectors and a GPU fuzzer, then prove a finding by replaying it on a forked mainnet — all in the browser.
BEVM is panel-based, like a security IDE. A top bar holds the target and command bar; the center hosts tabbed panels; an activity feed tracks running jobs. Open panels from the sidebar and arrange them as tabs or floating windows.
Aliases are used everywhere: attacker, target, me, zero, max. Type an alias
instead of a 0x address in most inputs and BEVM resolves it for you.
In the Smart Contract panel, either attach an existing contract by address (BEVM
fetches its on-chain bytecode) or paste raw bytecode (0x6080604052…). Once loaded, BEVM
disassembles the code and exposes its function selectors, so every other panel can operate
on the target.
The entry point: attach a target by address or bytecode, give it an alias (e.g. target),
and view its disassembly and detected selectors. Every session begins here.
Renders the contract's control-flow graph — basic blocks, jumps, and reachability. Click Run analysis to build it, then filter by selector or name to focus on a single function's paths. Use it to spot gated branches, computed jumps, and guarded code.
Encode and decode calldata and ABI-encoded values. Paste a 32-byte word or full calldata, optionally provide an ABI signature, and BEVM decodes the head/tail of dynamic types. Handy for reading a function's arguments or crafting one by hand.
Read and write contract storage slots on your fork. Look up a slot by number or by a declared mapping slot (key + base slot), using addresses or aliases as keys. Overriding storage lets you set up the exact state a candidate exploit needs.
Runs Trilocore's static detector suite over the bytecode — 200+ detectors across many categories — and lists findings with their category and the code address they hit. Fast, no execution; the first thing to run on any target.
Launches an active scan job that executes against the fork to find — and validate — real issues. The panel shows job status and findings as they arrive; results are backed by fork execution rather than static heuristics.
The fuzzing workbench. Mark payload positions in calldata and choose attack types (e.g.
battering ram) and wordlists — addresses (attacker/target/zero/max), bytes32
role/proxy-slot values, and more. BEVM's GPU fuzzer drives high-throughput execution to
surface inputs that move value or hit dangerous states.
Hand-craft and re-send a single transaction: pick a selector, fill arguments, set the sender
(attacker), value, and gas, then send it against the fork and inspect the result/return
data. The tool for iterating on a precise exploit transaction.
Compose and send exploit transactions with state setup. Teleport applies overrides
(balances, storage, etc.) and then sends the exploit tx — letting you reproduce an
attacker's starting conditions and confirm the outcome. Handles DELEGATECALL and
computed-jump targets in the flow.
Model exploits that span several contracts — e.g. flash loan → oracle → drain — as one
sequence, following DELEGATECALL and cross-contract calls. This is where real DeFi
kill-chains are reproduced end to end.
Inspect the EVM memory/heap and a call's profile during execution — calldata size, annotations, and how memory evolves. Useful for understanding ABI layout and memory-expansion behaviour.
Analyzes transient storage (EIP-1153 TSTORE/TLOAD): which functions store/load
transient keys, cross-function key reuse, and related findings.
Diff two states or transaction results — compare storage/state before and after a transaction to see exactly what an exploit changed.
In-workbench AI help: AI Explain turns a revert/error or a finding into a plain-English explanation, and AI Tasks suggests next steps. For deeper, attacker-style analysis, take the finding to Janus.
Support — Questions or want to support the project? Contact saiteja@trilocore.com.
Security is a team sport. Trilocore makes it trivial to work alongside your auditing team or share a reproducible proof-of-concept with a protocol.
Every BEVM session is fully shareable. When you uncover an exploit in a local fork, simply click Share Session. You'll generate a secure link that drops your teammate directly into the exact same fork state, with your calldata and overrides perfectly preserved.
Work on the same mainnet fork simultaneously. You can trigger a transaction, and your teammate can immediately see the state changes and build the next step in the exploit chain on their own machine.
Drafting reports manually is tedious. In the Collaborate tab, select your confirmed findings from the Active Scanner or your Repeater transactions, and Trilocore will automatically generate a highly detailed, markdown-formatted audit report ready to be submitted to a bug bounty program or a client.
Janus is an AI model that reasons like an attacker. Give it a contract or a finding and it explains the vulnerability in plain English, walks the attack chain, and suggests how to reproduce or fix it.
A chat console backed by an EVM-specialized model. Unlike a general chatbot, it's tuned for smart-contract security: attack-chain reasoning, exploit explanation, and turning raw findings into readable write-ups. It complements BEVM — BEVM finds and proves; Janus explains and reasons.
Janus is strongest on concrete, security-specific prompts. Examples:
0x… — what does that revert mean and how do I get past it?"You can include context with your message — paste bytecode, calldata, a Solidity snippet, or a finding. The more precise the context (selector, calldata, addresses, storage values), the sharper Janus's reasoning. Copy these straight from BEVM's Decoder, Storage, or Scanner panels.
Conversations are kept as sessions in the sidebar, so you can return to an analysis later. Keep one chat per target/investigation to preserve context.
The loop — BEVM finds & proves → Janus explains & suggests → BEVM replays to confirm.
Support — Questions or want to support the project? Contact saiteja@trilocore.com.