Renmy - Local Apex Runtime
Renmy was called Nimbus until 2026. This is the same extension you already have installed, and everything you set up under the old name keeps working: see Upgrading from Nimbus.
Run Salesforce Apex tests locally without deploying to an org. Renmy provides a full Apex execution environment with an embedded PostgreSQL database, giving you instant feedback on test results, coverage, and diagnostics — all from your editor.

Website & docs: renmy.net | CLI reference: renmy.net/docs | Community: Join the Slack

Getting Started
Prerequisites
First Run
- Open your Salesforce project folder in VSCode
- The extension activates automatically when it detects
sfdx-project.json or .cls files
- Check the status bar — you should see ✓ Renmy when the daemon is connected
- Open any
@isTest class — you'll see Run Test and Debug Test buttons above each test method
- Click
Run Test to run your first test
If the status bar shows ⊘ Renmy, the daemon failed to start. Run Renmy: Restart Daemon from the command palette (Cmd+Shift+P) and check the Renmy output channel for errors.
Running Tests
Every @isTest class shows CodeLens actions directly in the editor:
- On the class line:
Run All Tests runs every test method in that class, Validate checks syntax
- On each test method:
Run Test runs that single method, Debug Test starts a debug session, View Trace opens the trace viewer
Non-test classes also get CodeLens:
- On the class line:
Validate checks syntax
- On each public method:
Run executes the method, Debug starts a debug session
From the Command Palette
| Command |
What it does |
Renmy: Run All Tests |
Runs every @isTest class in the project |
Renmy: Run Tests in Current File |
Runs all tests in the active .cls file |
Renmy: Run Test Class |
Runs a specific test class by name |
Renmy: Run Test Method |
Runs a specific test method |
Renmy: Cancel Test Run |
Stops the currently running tests |
Renmy: Run On… |
Chooses where tests run — this machine, or a connected org |
From the Test Explorer
Renmy integrates with VSCode's native Test Explorer sidebar. Tests are discovered automatically when the daemon connects. You can run, debug, or view results from there.
Understanding Results
After a test run:
- A notification shows pass/fail summary with total time
- The Renmy output channel shows detailed results grouped by class
- Inline decorations appear in the editor on executed lines (pass/fail indicators)
- The status bar shows progress during the run (
3/10 tests...)

Running in a Salesforce Org
Every run gesture — CodeLens, the Command Palette, the Test Explorer — sends its
tests wherever the run target points. Renmy: Run On… changes it, and the
status bar and the top of the Renmy panel both state the current answer.
An org run is the same run: the same tree, the same coverage gutters, the same
governor readings and history. What differs is what it costs. The tests really
execute in the org, it takes as long as an org test run normally does, and any
data the tests create is created there — so every org run confirms first, and
the progress notification names the org while the org's first silent minute
(trace flag, enqueue, poll) goes by.
Runs are labelled by where they happened. A history row and a test row from an
org run say in <alias>; a local run stays unlabelled.
Two things stay on the local runtime, for the same reason: watch and
auto-run on save. Both re-run on every save, which in an org is minutes of
work and rows in somebody's sandbox per keystroke. Coverage is not one of them —
the org reports the lines it covered and the same gutters render them.
Debugging in an Org
With an org target, Debug Test runs the method there with tracing on and opens
a replay session over the log the org recorded. Salesforce cannot be attached to
from outside, so this is stepping through evidence rather than a live process —
with step-back, Variables and the timeline, exactly like a local recording.
If nothing opens, the message says which of the three things happened: the
method never ran, the org recorded no log for it, or the run already reported
why its evidence was thin.
Salesforce Debug Logs
A debug log Salesforce wrote — from a colleague, from CI, from Setup — converts
into the same trace the replay debugger already reads.
| Command |
What it does |
Renmy: Replay Salesforce Debug Log… |
Pick a .log from disk and step through it |
Renmy: Replay This Debug Log |
Same, on the open file — offered only when its first line really is a debug log header |
Renmy: Open Log from Org… |
Lists the org's retained logs, newest first, and replays the one you pick |
A log recorded below FINEST has no statement-level events, so there is nothing
to step through; the message names the level to set rather than saying no.
Open Log from Org… needs a Renmy CLI that can list org logs. Against an older
one it hides itself rather than failing on every click.
Debugging
Renmy supports the full VSCode debug experience for Apex code.

How to Debug a Test
- Open a test class
- Click
Debug Test above any @isTest method (or use Renmy: Debug Test Method)
- Set breakpoints by clicking the gutter (left margin) on any line
- The debugger pauses at breakpoints — use the debug toolbar to:
- Step Over (
F10) — execute the next line
- Step In (
F11) — enter a method call
- Step Out (
Shift+F11) — return to the caller
- Continue (
F5) — resume until the next breakpoint
- Pause — break into a run that is still executing
- Inspect variables in the Variables panel in the Debug sidebar
- View the call stack in the Call Stack panel — selecting a frame shows
that frame's variables
- You can also start a debug session from the Test Explorer's debug button
Breakpoints
Right-click a breakpoint in the gutter to make it more than a stop:
- Conditional breakpoint — an Apex expression; the run only stops when it
evaluates to
true (e.g. acc.Name == 'Acme')
- Hit count — stop only on the Nth hit
- Logpoint — never stops; writes a message to the Debug Console instead.
{expr} inside the message is evaluated in the paused frame
- Exception breakpoints — tick
Caught / Uncaught in the Breakpoints
panel to break where an Apex exception is thrown, and narrow them to
specific exception types
Inspecting and Changing State
- Watch panel — add any Apex expression; it is evaluated in the selected
stack frame
- Debug Console — type an expression to evaluate it on the spot
- Hover over a variable in the editor to see its value
- Set Value — right-click a variable in the Variables panel to change it
and continue with the new value
How to Debug Any Method
Not limited to tests — you can debug any public method:
- Open any
.cls file (non-test class)
- Click
Debug above any method
- If the method has parameters, Renmy prompts you to enter values
- Breakpoints and stepping work the same as test debugging
Replaying a Recorded Trace
If a run was recorded with renmy test --trace --trace-level verbose, you can
step through it afterwards without re-running anything:
- Run
Renmy: Replay Trace… from the Command Palette
- Pick a recorded run (newest first), or browse to a
trace.jsonl
- Step forwards and backwards — Step Back and Reverse Continue
appear in the debug toolbar, because replay walks a recorded timeline
rather than executing Apex
This is the way to debug a failure you have already reproduced once,
including one recorded in CI.
Launch Configurations
You can also configure debug targets in .vscode/launch.json. Pick
Renmy: Debug Apex Test, Renmy: Debug Method, or
Renmy: Replay Trace from the "Add Configuration" list, or write them
directly:
{
"type": "renmy-apex",
"request": "launch",
"name": "Debug My Test",
"mode": "launch",
"program": "MyTestClass.myTestMethod",
"stopOnEntry": false
}
{
"type": "renmy-apex",
"request": "launch",
"name": "Debug a method call",
"mode": "method",
"method": "AccountService.recalculate",
"isStatic": true,
"returnType": "Decimal",
"parameters": [{ "name": "accId", "type": "Id", "value": "'001000000000001'" }]
}
{
"type": "renmy-apex",
"request": "launch",
"name": "Replay last trace",
"mode": "replay",
"traceFile": "${workspaceFolder}/.nimbus/traces/2026-08-22T10-14-02_a1b2c3d4/trace.jsonl"
}
Useful attributes: program (the test), method / isStatic / returnType /
parameters (method mode), traceFile (replay mode), projectPath,
orgAlias, stopOnEntry, noDebug.
Configurations written for earlier versions still work: "type": "nimbus-apex"
starts the same debugger, test is accepted as an alias for program, and the
mode is inferred when it is not stated.
Coverage
Enabling Coverage
Set renmy.coverage.enabled to true in settings, or pass the --coverage flag from the CLI. After a test run with coverage enabled, three things appear:
Gutter Icons
Colored icons appear in the editor gutter (left margin) next to each line:
- Green circle — line was executed during the test
- Red circle — line was not executed
- Yellow circle — branch partially covered (e.g., only the
true path of an if was taken)
Toggle gutter icons on/off with the renmy.coverage.showGutterIcons setting.
Method Coverage Annotations
After each method signature, an inline annotation shows the coverage percentage:
public static void processRecords(List<Account> accounts) // 75% (3/4 lines)
Coverage Command
Run Renmy: Show Coverage to view the full coverage report in the output channel.
Trace Viewer
The trace viewer shows a detailed execution trace of every method call, branch decision, and variable assignment during a test run.
How to Open
- From CodeLens: Click
View Trace above any test method after running it
- From the command palette:
Renmy: View Execution Trace
What You See
The trace viewer opens as a side panel with three tabs:
- Call Tree — An indented tree of all method invocations. Each node shows the method name, duration, and status (pass/fail). Click a node to select it.
- Timeline — A horizontal waterfall chart showing execution over time. Wider bars = slower methods. Useful for spotting bottlenecks.
- Log — A filterable list of all trace events with timestamps. Use the search box at the top to filter by method name or event type.
Values
When you select a span in any view, the right sidebar shows:
- Values — the fields and variables the selected span wrote, with the statement that wrote each. Every local at a breakpoint is the debugger's view
- Debug Output — any
System.debug() output from that span
- Attributes — span metadata like source file, line number, and status
Click the Renmy icon in the activity bar (left sidebar) to open the Renmy views: Tools, Test History, Governor Limits, Schema Explorer and Releases.

Dependency Graph in Tools maps classes, triggers and tests, and what a change to one of them can reach:

Test History
Shows a list of past test runs, sorted newest first.
How to use:
- Click the Renmy icon in the activity bar
- The Test History view shows past runs with pass/fail icons and summary (e.g.,
3/3 passed (250ms))
- Expand a run to see results grouped by class, then by method
- Click a method to see its duration and error message (if failed)
- Use the refresh button in the view title to reload
Additional actions from the view title bar:
- Show History Trends — opens a chart showing pass rate over the last 30 days, plus a table of flaky tests (tests that flip between pass and fail)
Context menu on runs:
- Compare With... — select two runs to see a side-by-side diff (see Test Diff below)
Governor Limits
Shows Salesforce governor limit consumption per test method. Updated automatically after each test run.
How to use:
- Run some tests
- Open the Governor Limits view in the Renmy sidebar
- Each test method is listed with its highest limit usage percentage
- Expand a method to see individual limits:
- SOQL Queries, SOQL Query Rows, DML Statements, DML Rows, CPU Time, Heap Size, HTTP Callouts, Future Calls, Queueable Jobs, Email Invocations
- Limits are color-coded:
- Green — under 50% used
- Yellow — 50-80% used
- Red — over 80% used (close to hitting the limit)
Schema Explorer
Browse the local PostgreSQL database schema that Renmy uses to store SObject data.
How to use:
- Open the Schema Explorer view in the Renmy sidebar
- Tables are listed with row counts and column counts
- Expand a table to see:
- Columns — name, data type, and constraints (PK, nullable, FK)
- Outgoing references (
→) — foreign keys from this table to others
- Incoming references (
←) — foreign keys from other tables pointing here
- Use the refresh button to reload after schema changes (e.g., after importing new metadata)
Watch Mode
Automatically re-run tests when Apex files change.
How to Use
- Click the Watch: off button in the status bar, or run
Renmy: Toggle Watch Mode from the command palette
- If your project has multiple package directories (in
sfdx-project.json), a picker appears:
- Choose All Packages to watch everything
- Choose a specific package (e.g.,
force-app) to only watch that directory
- The status bar updates to show
Watch: force-app (or Watch: all)
- When you save any
.cls or .trigger file, tests re-run automatically
- After a watch-triggered run, the status bar briefly shows the result (e.g.,
Watch: all passed or Watch: 2 failed)
- Click the watch button again to disable
Watch runs on the local runtime whatever the run target is set to, and refuses
to start while the target is an org: re-running in one on every save is minutes
of work and rows in somebody's sandbox per keystroke.
Pulling from an Org
Renmy: Pull from Org while Watching (also Pull from Org under Tools in
the Renmy panel) makes an org a second source of changes while watch mode is on.
Every 15 seconds Renmy checks the org for changes made there, writes them into
the project and re-runs the tests they affect.
- The org is the run target's when it names one; otherwise a picker lists your
authorised orgs.
- A file edited here and in the org is kept, not overwritten. The Renmy output
says
Kept yours: AccountService.cls is edited here and in dev by Jane Doe. Compare with the org before pulling. and a warning says the same.
- Changes Renmy does not pull are listed with the command that fetches them,
or with the reason the pull failed. Members deleted in the org are listed,
and their files are kept.
- The status bar reads
Watch · pull dev while it runs.
- Each check spends API calls from the org's daily allowance. The pull is off
in every new window, goes off with watch mode, stops when the run target moves
to another org, and stops by itself with fewer than 1,000 calls left or after
three failed checks in a row.
Requires Renmy Pro and the Renmy CLI 1.47.0 or later.
After a test run, method execution times appear as inline annotations:
public static void processRecords(List<Account> accounts) // ⏱ 45ms
For methods called multiple times: ⏱ 45ms avg (3 calls)
How it works:
- Timings come from trace data when available (most accurate), or from test progress events as a fallback
- Annotations appear on method signatures in the active editor
- Toggle with the
renmy.performance.showInlineTimings setting
Test Diff (Compare Runs)
Compare two test runs side by side to see what changed.
How to Use
- Run
Renmy: Compare Test Runs from the command palette
- A picker shows your last 20 test runs — select Run A
- Select Run B from the remaining runs
- A side panel opens showing:
- Summary — pass/fail counts and dates for both runs
- Flipped Tests (highlighted) — tests that changed from pass→fail or fail→pass
- All Tests — full comparison table with status, duration changes (arrows show faster/slower), and change type (Flipped, Same, New, Removed)
You can also right-click a run in the Test History sidebar and select Compare With....
Diagnostics & Validation
Renmy validates Apex syntax in real time and reports errors in the Problems panel.
- On save: If
renmy.validateOnSave is enabled (default: true), every .cls and .trigger file is validated when you save
- Manual: Run
Renmy: Validate Current File to check the active file
- Quick fixes: Some parse errors offer code actions (lightbulb icon) with suggested fixes — e.g., adding missing semicolons
Errors appear as red squiggles in the editor and in the Problems panel (Cmd+Shift+M).
Execute Anonymous Apex
Run arbitrary Apex code without creating a class or test.
How to Use
- Open any
.cls file or create a new untitled file
- Write or select some Apex code
- Run
Renmy: Execute Anonymous Apex from the command palette
- If you have text selected, only the selection runs. Otherwise the entire file runs.
- Output appears in the Renmy output channel —
System.debug() statements show as DEBUG: lines
Run Any Method
Not just tests — you can run any public method directly from the editor.
How to Use
- Open any
.cls file (non-test class)
- Click the
Run CodeLens above a method
- If the method has parameters, input boxes appear for each parameter (with type hints)
- The method executes and results appear as:
- An inline decoration next to the method showing return value and execution time
- A notification if the method failed with an error message
When tests fail because of missing SObjects, fields, or other metadata not in your local project, Renmy detects what's missing.
How it Works
- Run tests — if metadata is missing, a warning notification appears: "3 missing metadata items detected"
- Choose one of:
- Fetch & Re-run — Renmy retrieves the missing metadata from your connected Salesforce org and automatically re-runs the failed tests
- Show Details — Opens the output channel showing exactly which metadata items are missing and the
sf CLI commands to retrieve them manually
- Dismiss — Ignore for now
- You can also run
Renmy: Fetch Missing Metadata & Re-run from the command palette at any time
All Commands
| Command |
Description |
Renmy: Run All Tests |
Run every test in the project |
Renmy: Run Tests in Current File |
Run tests in the active editor file |
Renmy: Run Test Class |
Run all tests in a specific class |
Renmy: Run Test Method |
Run a specific test method |
Renmy: Debug Test Method |
Debug a test with breakpoints |
Renmy: Debug Method |
Debug a single method call with supplied arguments |
Renmy: Replay Trace… |
Step forwards and backwards through a recorded trace |
Renmy: Cancel Test Run |
Stop the current test execution |
Renmy: Validate Current File |
Check Apex syntax, report errors |
Renmy: Execute Anonymous Apex |
Run selected/all Apex code |
Renmy: Show Coverage |
Display full coverage report |
Renmy: Toggle Watch Mode |
Enable/disable auto-run on save |
Renmy: Pull from Org while Watching |
While watching, pull changes made in an org and re-run the tests they affect |
Renmy: Show Status |
Show daemon version, uptime, DB status |
Renmy: Restart Daemon |
Restart the background daemon |
Renmy: View Execution Trace |
Open trace viewer for a test |
Renmy: Show Test History |
Show history in output channel |
Renmy: Show History Trends |
Open pass rate chart + flaky test table |
Renmy: Compare Test Runs |
Diff two historical runs side by side |
Renmy: Refresh Schema |
Reload schema explorer |
Renmy: Fetch Missing Metadata & Re-run |
Retrieve missing metadata from org |
Settings
| Setting |
Type |
Default |
Description |
renmy.binaryPath |
string |
renmy |
Path to the Renmy CLI. A bare name is looked up on your PATH and in ~/.nimbus/bin |
renmy.parallel |
number |
4 |
Number of parallel test workers |
renmy.coverage.enabled |
boolean |
false |
Collect coverage data on test runs |
renmy.coverage.showGutterIcons |
boolean |
true |
Show green/red/yellow coverage icons in the gutter |
renmy.coverage.showDelta |
boolean |
false |
Overlay coverage change against the saved baseline |
renmy.validateOnSave |
boolean |
true |
Validate Apex syntax on save |
renmy.autoRun.onOpen |
boolean |
false |
Auto-run tests when a test file is opened |
renmy.autoRun.onSave |
boolean |
false |
Auto-run tests when a test file is saved |
renmy.performance.showInlineTimings |
boolean |
true |
Show method execution time annotations |
renmy.governor.showCodeLens |
boolean |
true |
Show SOQL/DML limit usage above methods after a run |
renmy.lsp.enabled |
boolean |
true |
Run the Renmy language server for Apex; turn off to use Salesforce's Apex language server instead |
Upgrading from Nimbus
Renmy shipped as Nimbus until 2026. Nothing you set up needs to change:
- Settings:
nimbus.* settings are still read. The Settings editor lists the renmy.* names, and where both are set in the same place, renmy.* wins.
- Launch configurations:
"type": "nimbus-apex" still starts the debugger. New configurations are written as renmy-apex.
- The CLI: a binary installed as
nimbus is found as well as one installed as renmy.
- Keybindings: command ids keep their
nimbus. prefix, so a keybinding you made still works.
.nimbus/ and ~/.nimbus keep their names on purpose. They hold your license, the local database and your recordings, and moving them would sign you out and rebuild the database.
Support & Feedback
Core features (test execution, coverage, debugging, SOQL) are stable and used daily. We're continuously expanding Apex language coverage and shipping fixes fast.
License
Proprietary — see the Renmy EULA for terms. Free tier available; Pro features are free with a Pro license.