Your Salesforce team is waiting on the org. That time costs money.

renmy runtime runs your team's Apex tests on the developer's machine instead of in an org. A test run that takes 29 minutes through Salesforce finishes in 82 seconds, so every change reaches your customers sooner.

macOS, Linux and Windows. Free tier, no card.

The same run through the orgsrenmy runtime, local Apex test runs
SANDBOXSTAGINGPROD
29 min82 sfor the 3,985 Apex tests of NPSP: 29 minutes through the org, 82 seconds on your machine. Measured.
renmy test InvoiceServiceTest
PASS recalculatesNetTotalPASS rejectsNegativeAmount
53 ms
no org round-trip

Apex test benchmarks: the same Apex tests on your machine and through the org

  • renmy runtime, local Apex test run
  • Salesforce org: deploy, then run the tests
  1. NPSP3,985 Apex tests. Nonprofit Success Pack: households, donations, rollups, data import
    82 s29 m 06 s
    21×
  2. EDA2,357 Apex tests. Education Data Architecture: affiliations, addresses, course connections
    18.5 s12 m 19 s
    40×
  3. nebula-logger1,354 Apex tests. Logging framework: platform events, custom metadata, async jobs
    4.7 s1 m 43 s
    22×
  4. dlrs830 Apex tests. Declarative rollups: generated triggers, dynamic SOQL
    2.0 s2 m 20 s
    68×
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
  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. All 8,526 tests in four large open-source Apex projects pass on both, so the only difference is the waiting.

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. The method and every run

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. Each blue dot crosses in one second and each yellow dot in as many seconds as the factor beside it. Every run behind these medians

One runtime, for the developer who tests and the company that ships

For developers

Try it on your own code today

Install one binary and run your test classes. Apex, SOQL, DML, triggers and flows execute for real, on an embedded database.

curl -fsSL https://renmy.net/install.sh | sh
  • A live debugger in VS Code and JetBrains
  • Watch mode, parallel tests and mutation testing
  • What runs locally, with commands and real output
For companies

Take the waiting out of every release

Every hour a developer waits on the org is an hour not spent on the features your revenue depends on.

$130,000a year returned to the business. An estimate from the calculator's defaults: 5 Apex developers at $80 an hour.
  • Tests and release workflows on every pull request
  • Your source and schema stay on your machines
  • Release evidence in the on-prem Assurance console
Calculate your savingsTeam and Enterprise

Calculate your savings: what the org costs your business, in hours and dollars

Build the business case for transforming your Salesforce delivery. Enter your own numbers. Every figure on the right is arithmetic on the fields on the left, and the fields hold the whole model: there is no hidden multiplier. The numbers stay in your browser.

Your team
USD
min
min

The estimate also counts failures from shared test data, new developers waiting for org access and CI failures unrelated to the code, at the defaults.

7.0 hPer developer per week
$130,053Per year, 5 developers
9Working days until the year's plan is paid back

Team plan, 5 seats: $4,740 a year at the published price, before tax. Net of the plan: $125,313 a year.

Book a call

Choose how your team gets started

Pro and Team are free for now.

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

Team

$79$0/developer/month

Team features free for now, no card required

Automate testing and releases for your team

Every developer gets Pro, plus a dedicated CI license, shared release evidence and central seat management. Run tests on every pull request and manage access as people join or leave.

Prices are net, plus VAT where it applies. Pro and Team are sold to businesses only (§ 14 BGB).

  • 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
Start testing with your team

Why choose Team over Pro?

Pro makes an individual developer faster. Team puts those tools into your delivery process, with automated checks in CI and shared evidence of what was validated and released.

  • Test every pull request. Run tests and release workflows on CI runners with a dedicated CI license, including ephemeral build agents.
  • Keep release evidence together. Use the on-prem Assurance console to inspect signed release receipts across your workflow.
  • Manage the whole team. Assign and revoke developer seats centrally, with priority email support.

Several Pro licenses do not include CI access. If everyone only needs local development tools, Pro is enough. Choose Team when you want renmy runtime in your automated delivery pipeline. Team starts at three developer seats; each seat includes Pro.

Enterprise, from $40,000 per year. For a supported rollout across teams: agreed seats and CI usage, a named contact, contractual support coverage, DPA and PO billing. SSO and on-premise license validation scoped on request. Implementation and custom development are scoped and priced separately. Setup fees do not offset the annual subscription. Annual contract. Prices net, plus applicable taxes. Final scope and fees follow a written quote.Compare Team and Enterprise
Org-less CI setup. A fixed-fee engagement for teams whose Apex is still in the org and whose tests only run there. From $15,000, by Apex surface. Setup is a separate implementation engagement. Its fee does not offset the annual subscription. Basic onboarding is free. A service contract with Renmy UG (haftungsbeschränkt).Fixed prices, net, plus VAT. For businesses only (§ 14 BGB).How the setup works

One tool for local development, CI and validated releases

Run locally

Execute Apex and its surrounding platform services on your machine.

9 features in this group

Understand failures

Find the cause, measure the risk, and see what a change can reach.

7 features in this group

Ship safely

Use the same local evidence to gate releases and Salesforce deployment.

4 features in this group

Work in your tools

Keep the local runtime close to the editor, terminal, and agents you use.

9 features in this group
For developers: what runs locally, six checks to verify, the full toolchain

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

Find failures earlier and ship with evidence

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

“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
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.

Compared with the usual ways of running Apex tests

Compare your options
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.

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. For now, sign up for a free Pro license.

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

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