Seven engines
in one binary

A tree-walking interpreter over a full parse of every class, interface, and trigger in the project, with no bytecode, no transpilation, and no rewriting of your source. Trigger contexts, static state, async jobs, and exception behaviour follow the platform's order of execution, and errors carry the messages Salesforce raises. The test runner, the debugger, and anonymous execution all run through it.

Translates each SOQL statement into PostgreSQL at the moment it runs: bind variables, parent and child relationship traversal, aggregates and GROUP BY, date literals, and the sharing clauses. Dynamic queries through Database.query take the same path as inline ones, so both see the same semantics. Nothing is stubbed or pattern-matched; the rows come back from a real query planner.

An embedded PostgreSQL that renmy runtime starts, tunes, and shuts down itself, with no Docker, no service to install, and no port to claim. It carries the Salesforce data model: standard objects and their fields, the custom objects in your source, field-level security, record types, and rollup summaries. Each test runs inside its own transaction and is rolled back afterwards, so one test never sees another's data.

Wraps every write so transaction boundaries behave the way the platform's do: savepoints and rollback, allOrNone false, and per-record success and error results on every DML verb. A failure inside a test fails the way the org fails it: caught, partial, or rolled back to the savepoint you set. The bookkeeping stays off the per-statement path, so that fidelity costs no measurable run time.

Record-triggered flows, autolaunched flows, and subflows are loaded straight from your metadata and executed in the platform's order-of-execution slots: before-save flows ahead of before triggers, after-save flows after the after-trigger step. They see the same records your Apex sees, and their DML re-enters the same pipeline, so flows, triggers, formulas, and rollups interleave the way they do in an org.

Records a managed package from a real org once (its classes, its constants, and the answer it gives to each call) and writes the tape to disk. After that the package replays offline and deterministically, with no org connection in the loop. The recordings are files you commit, so CI and every developer on the team replay the same answers.

Presses the seal on a release. renmy release validate runs your local gates plus a real Salesforce check-only validation and writes an immutable receipt; after approval, renmy release deploy ships exactly the payload the receipt names, on any machine. The seal is earned by inspection: the save-time rules Salesforce applies to metadata run locally first, so dangling references, invalid API versions, and compiler rejects surface before anything is pushed.

The receipt is the contract. It records everything the deploy will re-check and expires (ten days by default), and renmy release deploy accepts only a matching, unexpired one. There is no bypass flag. Where the org-side validation ran tests, the deploy is a quick deploy: Salesforce ships the payload it already checked rather than checking it twice. renmy validate runs the save-time rules on their own, before any of this; renmy deploy runs the whole cycle end to end.