renmy runtime was called Nimbus until October 2026. Same tool, same binary; the record of the rename is Nimbus is now renmy runtime.
Short version. Salesforce Apex reads like Java, but the compiler, the runtime, the database and the test runner all live in Salesforce's cloud, so "run" turns into "deploy, wait, read a log". renmy runtime is a local Salesforce Apex runtime: one binary that executes real Apex, SOQL, DML and Salesforce Flows on your machine against an embedded PostgreSQL, with no org, no Docker and no JVM. It gives a Java developer the loop back: renmy test answers in tens of milliseconds, the JetBrains plugin puts live breakpoints in IntelliJ IDEA, coverage counts branches, and CI gets JUnit XML without an org. What stays different is the platform: governor limits, order of execution and a schema defined in metadata.
Who this is for
You write Java, Kotlin, Go or TypeScript. Someone handed you a Salesforce project, you opened a .cls file, recognized most of it, and then found out there is no way to run it. This article maps what you know onto Salesforce, then shows how renmy runtime puts the familiar tools back. What a local Apex runtime is starts from zero.
Why does Salesforce Apex have no local run button?
Apex is the server-side language of the Salesforce Platform (not Oracle APEX, an unrelated product). It is statically typed, class-based, and borrows Java's syntax almost wholesale: public class, interface, enum, List<Account>, try/catch/finally, static, super.
@IsTest
private class InvoiceServiceTest {
@TestSetup
static void makeData() {
insert new Account(Name = 'Acme Logistics');
}
@IsTest
static void appliesTaxOnce() {
Account acme = [SELECT Id FROM Account WHERE Name = 'Acme Logistics'];
Test.startTest();
Decimal total = InvoiceService.total(acme.Id, 100.00);
Test.stopTest();
System.assertEquals(119.00, total);
}
}
The difference is not the language but where it runs. Java gives you javac and a JVM on your laptop; Apex gives you neither. The compiler runs inside your Salesforce org when you deploy. The runtime is the org, the database is the org, the test runner is the org. Salesforce never shipped an interpreter you could download; Apex executes only on the platform, beside the data. Everything that feels strange about Salesforce development follows from that:
-
javacbecomes deploy. Code compiles when you push it to an org. A type error is a failed deployment, not a red underline. - The JVM becomes the org. No process on your machine can execute a class.
-
JUnit becomes
@IsTestafter a deploy. The test framework is built into the language, but the only place it ran was the org. - The debugger becomes debug logs. You run the code, download a log and read it. The platform's replay debugger steps through that log afterwards; it does not stop a running program.
- H2 and Testcontainers become the org's database. Tests create their own records in Apex; the platform rolls each test back.
-
docker compose upbecomes a sandbox or a scratch org. A sandbox is a copy of a production org; a scratch org is a disposable org built from your source. Both live in Salesforce's cloud and take minutes to prepare. - JaCoCo becomes a 75% deployment gate. Production deployments require 75% line coverage across the org. It is a gate, not a quality measure, and the org reports lines only.
What does deploy-to-run cost a Java developer?
Your loop is edit, run, read, fix, at the speed of a keyboard. The Salesforce loop is edit, deploy, wait, run tests, wait, read a log, fix. Every iteration crosses the internet. The published benchmark puts a number on it: four open-source Apex suites, 837 tests, about 1 min 46 s in a Salesforce org (deploy and run) versus 2.4 s locally, roughly 45× faster, every test passing in both. That is one iteration; a working day has dozens.
The second-order costs follow: CI needs an org and a certificate to reach it, a Salesforce outage stops development, and an AI coding agent, which needs a write-run-fix loop measured in seconds, cannot iterate on Apex.
What is a local Apex runtime?
A local runtime is the thing Java developers never had to name, because it was always there: a program on your machine that executes the language. For Apex it has to interpret the language, provide a real database for SOQL and DML with the platform's transaction semantics, and enforce the platform's rules, from governor limits to the order in which triggers and flows fire.
renmy runtime does this in one binary for macOS, Linux and Windows. It executes real Apex (classes, interfaces, enums, generics, triggers), SOQL and DML, and Salesforce Flows (autolaunched, record-triggered and screen) against an embedded PostgreSQL. It is not a mock framework and not a transpiler to Java, and it does not claim to be the platform: the parity record is public and lists what matches and what does not.
How to get the Java developer loop back in Salesforce
Run tests from the terminal
Install, then run the suite from the root of a Salesforce DX project:
curl -fsSL https://renmy.net/install.sh | sh # macOS, Linux
irm https://renmy.net/install.ps1 | iex # Windows PowerShell
cd your-sfdx-project
renmy test "*" # the whole suite
renmy test InvoiceServiceTest # one class, like one JUnit class
renmy test InvoiceServiceTest.appliesTaxOnce # one method
renmy test "*" --coverage # line and branch coverage
A typical test completes in tens of milliseconds, SOQL and DML included, and nothing is deployed. renmy validate type-checks a change without running it, the way javac would. When a test fails, renmy explain InvoiceServiceTest.appliesTaxOnce prints the exception, the source location, expected versus actual, and the SOQL and DML that ran just before the failure, which replaces the debug log for the common case.
Breakpoints in IntelliJ IDEA
The JetBrains plugin, Renmy Runtime - Salesforce IDE, gives Apex the workflow IntelliJ users have for Java: a run icon in the gutter on every @IsTest class and method; Run, Debug, Coverage and Trace code lenses; results streaming into IntelliJ's test runner tree, each method with its time and SOQL and DML counts inline.
The debugger is a native IntelliJ debug session against the local runtime: breakpoints in .cls and .trigger files, step over, into and out, variables per frame, watches, evaluate, break on exceptions. It stops the running test at the line you chose; it is not a log replay. Stepping is a Pro feature and free during the public beta; recording a run is free.
It works in IntelliJ IDEA Community and Ultimate, and in any JetBrains IDE from 2025.3 that ships JCEF, with no JDK of your own; the plugin installs the runtime on first open of a Salesforce DX project. The full tour is renmy runtime for JetBrains; the VS Code extension debugs over the same DAP backend.
A console for the database
In Java you keep a database console open. The JetBrains plugin has a SOQL console and an Apex console; both run against the local runtime or any org the Salesforce CLI is logged in to, and "Run and Compare" runs the same code in both and shows what differs. From the terminal, renmy exec runs anonymous Apex the way jshell runs an expression.
Coverage that counts branches
renmy test "*" --coverage measures line and branch coverage, which is what JaCoCo gives you and what the org does not. Reports come out as HTML, JSON, Cobertura XML and JUnit XML; renmy coverage diff gives the delta for a pull request, and --min-coverage fails a run below a threshold. Details at coverage and Apex branch coverage.
Mutation testing
If you have run PIT on a Java codebase, mutation testing in renmy runtime is the same idea for Apex: the runtime mutates your code and checks whether the tests notice. To our knowledge it is the first for Apex. It is a Pro feature, free during the public beta, and the answer to the 75% question.
CI without an org
The unit-test job in CI needs no org either: no JWT certificate, no Dev Hub, no scratch org pool for that stage.
jobs:
apex-tests:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- run: curl -fsSL https://renmy.net/install.sh | sh
- run: renmy test "*" --coverage
The run emits JUnit XML and Cobertura, so the CI server reports Apex tests next to everything else. Running tests in CI is part of the Team tier, free during the public beta; templates are at CI/CD and Apex CI without an org. The deploy side keeps its gate: renmy deploy (Free) runs the local gates, validates the identical bytes in the org with a real check-only validation, and only then deploys.
Where Salesforce Apex still differs from Java
A local runtime removes the round trip, not the platform. Three things will keep tripping you up until they become reflexes.
Governor limits. Every transaction has a budget: 100 SOQL queries and 150 DML statements in a synchronous transaction, plus CPU time and heap. A for loop with a query inside it is idiomatic Java and a production incident in Apex. renmy runtime enforces the limits locally, so the test fails on your machine with the exception it would raise in the org. Details at governor limits.
Order of execution. A single insert can fire before and after triggers, record-triggered Salesforce Flows, validation rules and more. It is closer to a database with a stack of triggers than to repository.save(). The runtime runs triggers and flows together on the same DML, so the interactions show up locally.
Metadata. The schema is XML in your repository, one file per object and field, with custom fields ending in __c. renmy runtime takes its local schema from that metadata, and renmy fixture reads it to generate a test data factory with required fields and lookups filled in.
Try it
curl -fsSL https://renmy.net/install.sh | sh
cd your-sfdx-project
renmy test "*"
The quickstart takes under five minutes. The runtime is free for individual developers: no card, unlimited local test runs, one machine. Issues, docs and binaries are on GitHub. For IntelliJ IDEA, install Renmy Runtime - Salesforce IDE from the Marketplace.
Frequently asked questions
Is Salesforce Apex the same as Java?
No. Apex borrows the syntax of Java: classes, interfaces, enums, generic collections, exceptions and static typing. There is no JVM, no bytecode you can run, and it executes only on the Salesforce Platform, where governor limits cap how many queries, DML statements and CPU milliseconds one transaction may use. A Java developer reads Apex on day one and spends the following weeks learning the platform rules.
Can I run Apex tests locally without a Salesforce org?
Yes, with renmy runtime, a local Salesforce Apex runtime: one binary that executes real Apex, SOQL, DML and Salesforce Flows on your machine against an embedded PostgreSQL, with governor limits enforced and per-test transaction isolation. The command renmy test "*" runs the whole suite, and a typical test completes in tens of milliseconds. It needs no org, no scratch org, no sandbox, no Docker and no JVM, and the Free tier covers unlimited local test runs on one machine.
Can I debug Apex with breakpoints in IntelliJ IDEA?
Yes. The JetBrains plugin, Renmy Runtime - Salesforce IDE, runs a native IntelliJ debug session against the local runtime: breakpoints in .cls and .trigger files, step over, into and out, variables per frame, watches, evaluate, and break on exceptions. It stops a running test; it is not a replay of a debug log. It works in IntelliJ IDEA Community and Ultimate from 2025.3. Stepping is a Pro feature, free during the public beta.
What is the JUnit equivalent in Salesforce Apex?
The test framework is built into the language: classes marked @IsTest, test methods, assertions, @TestSetup for shared data, and Test.startTest() and Test.stopTest() to reset governor limits and flush asynchronous work. What Apex lacks is a local runner: in Salesforce, tests run inside an org after a deploy. renmy runtime runs the same test classes on your machine and emits JUnit XML and Cobertura reports, so a CI server treats them like any other suite.
Do I still need a sandbox or scratch org with renmy runtime?
Yes, for the parts that are org-shaped: the UI, integrations, permissions a human clicks through, and the final validation before production. renmy runtime takes the inner loop off the org, the hundred edit-run-fix cycles between a failing test and a passing one, and renmy deploy validates the identical bytes in the org before it deploys. The sandbox is where you ship; the runtime is where you work.
Top comments (0)