Apex tests, flows and deploys. On your machine, no org.

renmy runtime runs your Apex tests and your Salesforce flows on your machine, against an embedded PostgreSQL. On a laptop it runs almost 4,000 tests in 82 seconds, where Salesforce needs 29 minutes to deploy and run them.

curl -fsSL https://renmy.net/install.sh | sh
QuickstartHow it comparesmacOS, Linux, Windows. Free tier, no card.
renmy test InvoiceServiceTest
PASS recalculatesNetTotalPASS rejectsNegativeAmount
53 ms
no org round-trip
RuntimeRuns on an embedded database. Nothing to install besides renmy runtime.
ExecutionApex, SOQL, DML, triggers and Salesforce flows execute for real.
CIWrites JUnit XML and Cobertura for your CI.
PrivacyYour source and schema stay on your machine.

“Renmy saved Claude and me many hours of wall-clock time on developing and debugging apex code. Very reliable, repeatable and fast!”

Antal GodkewitschWorking for Fair Wear
  1. renmy runtime runs almost 4,000 Apex tests in 82 seconds; Salesforce needs 29 minutes to deploy and run the same tests.
  2. Changing one class and rerunning its tests takes 19 seconds against a Salesforce org and under a second on renmy runtime.
  3. Running the full suite five times a day gives each developer 2 hours 19 minutes back.

Measured 2026-10-29 on the Nonprofit Success Pack (NPSP, 3,985 tests), Salesforce.org's open-source app for nonprofits: a full deploy and a test run with parallel testing disabled in a Salesforce scratch org, against renmy runtime 1.64.0 on a MacBook Air. Five runs a day is an example; the saving is arithmetic on the medians. The method and every run

Benchmarks

Four of the largest open-source Apex suites, 8,526 tests, deployed to and run in a Salesforce scratch org with parallel testing disabled, then run on renmy runtime 1.64.0 on a MacBook Air. Every test passes in both. Measured 2026-10-29.

Every run behind these medians
45 m 28 sSalesforce org, deploy and test
1 m 47 sSame tests, on a laptop
43 m 41 sLess waiting on every full run
SuiteTestsOrgrenmyFactor
NPSPNonprofit Success Pack: households, donations, rollups, data import3,98529 m 06 s1 m 22 s21×
EDAEducation Data Architecture: affiliations, addresses, course connections2,35712 m 19 s18.5 s40×
nebula-loggerLogging framework: platform events, custom metadata, async jobs1,3541 m 43 s4.7 s22×
dlrsDeclarative rollups: generated triggers, dynamic SOQL8302 m 20 s2.0 s68×

What runs locally

renmy runtime parses every class, interface, trigger and flow in the project and interprets it directly. There is no transpilation step and nothing is stubbed.

Language
  • Classes, interfaces, enums
  • Inheritance and polymorphism
  • Generics and typed collections
  • Exception handling
  • All Apex annotations
Data
  • SOQL queries
  • DML: insert, update, delete, upsert
  • Bind variables
  • Aggregate functions
  • Relationship queries
Automation
  • Before and after triggers
  • Record-triggered, autolaunched and platform event flows
  • Subflows, flow formulas and decisions
  • Validation, duplicate, assignment and workflow rules
  • Process Builder and approval processes
Testing
  • @isTest and @testSetup
  • System.assert variants
  • Test.startTest / stopTest
  • Stub API and ApexMocks
  • Per-test transaction isolation

Compared with the usual ways of running Apex tests

Full comparison, including what renmy runtime cannot do
Today
With renmy
Scratch orgs
Push the source, wait, run the tests, wait again. Two to ten minutes per cycle, and DevHub limits on top.
Nothing to push. The tests run against the embedded database in milliseconds.
ApexMocks
Everything is stubbed, so the tests pass while the SOQL, triggers, flows and DML they depend on go untested.
The SOQL, DML, triggers and flows execute against a real database, at about the speed of a mocked test.
Sandbox CI
A JWT certificate, a connected org and a scratch org pool, and failures that have nothing to do with your code.
renmy test writes JUnit XML and Cobertura, which GitHub Actions, GitLab, SonarQube and Codecov already read.
Deploying
sf project deploy ships whatever is in the worktree, which may not be the revision the tests ran against.
renmy deploy snapshots the payload, runs the local gates, validates that exact payload in Salesforce and then deploys it, with a receipt.

Six things worth checking before you trust it

The SOQL, DML, triggers and flows actually run

renmy runtime executes Apex and flows against a real embedded PostgreSQL. Queries return rows, triggers fire, record-triggered flows run and DML persists inside the test transaction. There is no simulated runtime and no stubbed return value, and a typical test still completes in tens of milliseconds.

Why an embedded database
Salesforce flows execute locally, beside the Apex

renmy runtime reads the flow metadata in your repo and runs it. Record-triggered flows fire on DML in the platform's order of execution, autolaunched flows and subflows run with their decisions and formulas, and platform event flows subscribe locally. Nothing is deployed and the test class needs no changes.

How flow execution works
A live debugger, in VS Code and JetBrains Pro

The Apex Replay Debugger works from a log after the fact. renmy runtime attaches to the running test, so you get breakpoints, stepping and variable inspection while it executes.

See the debugger
Mutation testing for Apex Pro

renmy runtime changes your code in small ways, flipping operators, negating conditions and altering return values, then reruns the tests to see whether they notice. 75% line coverage says nothing about whether a test would fail when the code is wrong.

How mutation testing works
A structured trace of every run Pro

Each run produces an OpenTelemetry trace of method calls, SOQL, DML, triggers, branches and assignments, shown as a tree you can expand. It replaces reading a 40,000-line debug log.

Explore traces and analytics
Local and org results, compared Pro

renmy compare runs the same tests in a connected org and diffs the outcomes, governor usage and traces against the local run. Fidelity is something you check on your own code rather than something we claim.

The org parity record

Everything in the binary

Each entry links to its own page, with the details and the limitations.

Run
Real Apex runtime Classes, SOQL, DML, triggers and flows on an embedded databaseManaged packages Record once, run NPSP and Nebula Logger locallyFlow testing Record-triggered, autolaunched, screen
Edit
Apex Language Server Lenses, inlay hints, call hierarchyVS Code and JetBrains Run buttons, inline results, gutters
Test
Mutation testing ProDo your tests catch mutantsCoverage and CI ProLine and branch, JUnit, Cobertura, HTML
Debug
Live step debugger ProBreakpoints over DAP, liveExecution traces ProOpenTelemetry trace of every callBrowser Dev UI Explorer, coverage, schema, Apex REPL
Integrate
MCP for AI agents Native JSON-RPC write-test-fix loopsLocal Salesforce API ProREST and Pub/Sub gRPC on localhostBackground daemon ProWarm once, start in milliseconds
Ship
Gated deploys Local gates, org validation, deployRelease receipts ProValidate once, quick-deploy the same bytesSalesforce CLI pass-through Any sf command through renmy sf

Pricing

Pro and Team are free during the beta.

Free

$0

For individual developers

  • Apex runtime, real execution
  • Unlimited test runs
  • SOQL, DML, triggers and flows
  • Code coverage (console, JSON, HTML)
  • Governor limit enforcement
  • Gated deploys (renmy deploy)
  • Salesforce CLI pass-through (renmy sf)
  • VS Code and JetBrains integration
  • 1 machine
  • Community support
Install

Pro

$19$0/month

Free during the beta, no card required

  • Everything in Free
  • Background daemon (renmy daemon)
  • Local Salesforce platform (renmy serve): REST and Pub/Sub gRPC
  • Parallel test execution
  • Watch mode
  • Debugger with breakpoints
  • Coverage gutter icons in VS Code
  • Mutation testing
  • Generated managed-package stubs
  • Org fallback
  • Compare a test run with the org: outcomes, governor usage, traces
  • JUnit XML and Cobertura output
  • Assured releases from your machine: signed receipts, drift guard, promote and rollback
  • LSP: lenses, inlay hints, call hierarchy
  • MCP server for AI agents
  • 1 developer, 3 machines. Does not run in CI
Get a free Pro license

Team

$49$0/developer/month

Free during the beta, no card required

  • Everything in Pro
  • Test runs in CI: GitHub Actions, GitLab and any runner that sets CI
  • Release workflows in CI
  • Dedicated CI runner license with its own machine pool
  • Assurance console, on-prem
  • License management portal: assign and revoke seats
  • 3 seats minimum, 3 machines per seat
  • Priority email support
Get a free license
Enterprise, from $20,000 per year: unlimited seats and CI runners, a support SLA, DPA and PO billing, SSO and on-premise license validation on request.renmy runtime for teams
Org-less CI setup. A fixed-fee engagement for teams whose Apex is still in the org and whose tests only run there. $7,500 to $25,000, by Apex surface. Two weeks. The setup fee is credited against the Enterprise plan if you buy it within a year of the setup. Basic onboarding is free. A service contract with Renmy UG (haftungsbeschränkt) i.G..Fixed prices, net, plus VAT. For businesses only (§ 14 BGB).How the setup works

Questions

What about platform fidelity?

renmy runtime runs the tests that exercise business logic, SOQL, triggers, flows and class behaviour. The aim is full parity with the platform, so that your org is needed only for final validation and deployment, and for browser-based UI testing.

Is a real database slower than an in-memory runtime?

No. A typical test completes in tens of milliseconds, real SOQL and DML included. The embedded PostgreSQL is tuned for test workloads, with a unix socket and fsync and WAL switched off.

What runs locally versus on Salesforce?

Everything renmy runtime supports runs on the developer machine. No source code or schema leaves the laptop. The org remains the deployment target and the system of record.

How does this fit a release pipeline?

Pre-merge: renmy test in CI with no connected org. JUnit XML and Cobertura go to the tools you already run. Pre-deploy: renmy release validate runs the local gates plus a real Salesforce check-only validation and writes a receipt. After approval, renmy release deploy ships exactly that payload.

Install

renmy runtime is a single binary for macOS, Linux and Windows. The Free tier needs no account and no card. During the beta, sign up for a free Pro license.

Questions go to the Slack or to support@renmy.net.

curl -fsSL https://renmy.net/install.sh | sh
then: cd your-sfdx-project && renmy test "*"