Skip to content
| Marketplace
Sign in
Visual Studio Code>Programming Languages>Renmy - Local Apex RuntimeNew to Visual Studio Code? Get it now.
Renmy - Local Apex Runtime

Renmy - Local Apex Runtime

Renmy UG (haftungsbeschränkt)

|
59 installs
| (0) | Free
Run Salesforce Apex tests locally with Renmy. Test Explorer integration, real-time results, coverage, and diagnostics. https://renmy.net
Installation
Launch VS Code Quick Open (Ctrl+P), paste the following command, and press enter.
Copied to clipboard
More Info

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.

VSCode License

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

All 153 Apex tests of a demo project passing in the VS Code Test Explorer in 2.4 seconds, run locally by Renmy


Getting Started

Prerequisites

  • Renmy CLI — the extension will offer to install it automatically on first launch. You can also install manually:
    curl -fsSL https://install.renmy.net | sh
    
  • A Salesforce project with sfdx-project.json

First Run

  1. Open your Salesforce project folder in VSCode
  2. The extension activates automatically when it detects sfdx-project.json or .cls files
  3. Check the status bar — you should see ✓ Renmy when the daemon is connected
  4. Open any @isTest class — you'll see Run Test and Debug Test buttons above each test method
  5. 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

From CodeLens (Inline Buttons)

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

A test class after a run: each test method shows whether it passed and how long it took, with Run, Debug, Coverage and View Trace above it


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.

Paused on a breakpoint in an Apex service called from a test: locals, arguments and the call stack in the sidebar, two expressions evaluated in the Debug Console

How to Debug a Test

  1. Open a test class
  2. Click Debug Test above any @isTest method (or use Renmy: Debug Test Method)
  3. Set breakpoints by clicking the gutter (left margin) on any line
  4. 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
  5. Inspect variables in the Variables panel in the Debug sidebar
  6. View the call stack in the Call Stack panel — selecting a frame shows that frame's variables
  7. 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:

  1. Open any .cls file (non-test class)
  2. Click Debug above any method
  3. If the method has parameters, Renmy prompts you to enter values
  4. 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:

  1. Run Renmy: Replay Trace… from the Command Palette
  2. Pick a recorded run (newest first), or browse to a trace.jsonl
  3. 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

Sidebar: Renmy Panel

Click the Renmy icon in the activity bar (left sidebar) to open the Renmy views: Tools, Test History, Governor Limits, Schema Explorer and Releases.

The Renmy panel beside an Apex class with coverage in the gutter and a covered-by-29-tests lens above the method

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

The dependency graph of the demo project's classes, triggers and tests

Test History

Shows a list of past test runs, sorted newest first.

How to use:

  1. Click the Renmy icon in the activity bar
  2. The Test History view shows past runs with pass/fail icons and summary (e.g., 3/3 passed (250ms))
  3. Expand a run to see results grouped by class, then by method
  4. Click a method to see its duration and error message (if failed)
  5. 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:

  1. Run some tests
  2. Open the Governor Limits view in the Renmy sidebar
  3. Each test method is listed with its highest limit usage percentage
  4. 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
  5. 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:

  1. Open the Schema Explorer view in the Renmy sidebar
  2. Tables are listed with row counts and column counts
  3. 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
  4. 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

  1. Click the Watch: off button in the status bar, or run Renmy: Toggle Watch Mode from the command palette
  2. 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
  3. The status bar updates to show Watch: force-app (or Watch: all)
  4. When you save any .cls or .trigger file, tests re-run automatically
  5. After a watch-triggered run, the status bar briefly shows the result (e.g., Watch: all passed or Watch: 2 failed)
  6. 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.


Inline Performance Annotations

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

  1. Run Renmy: Compare Test Runs from the command palette
  2. A picker shows your last 20 test runs — select Run A
  3. Select Run B from the remaining runs
  4. 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

  1. Open any .cls file or create a new untitled file
  2. Write or select some Apex code
  3. Run Renmy: Execute Anonymous Apex from the command palette
  4. If you have text selected, only the selection runs. Otherwise the entire file runs.
  5. 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

  1. Open any .cls file (non-test class)
  2. Click the Run CodeLens above a method
  3. If the method has parameters, input boxes appear for each parameter (with type hints)
  4. 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

Auto-Retrieve Missing Metadata

When tests fail because of missing SObjects, fields, or other metadata not in your local project, Renmy detects what's missing.

How it Works

  1. Run tests — if metadata is missing, a warning notification appears: "3 missing metadata items detected"
  2. 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
  3. 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.

  • Report bugs: github.com/renmy-solutions/renmy/issues
  • Docs & changelog: renmy.net/docs
  • Community: Join the Slack — questions, patterns, what AI agents are doing with the MCP tools
  • Support: support@renmy.net

License

Proprietary — see the Renmy EULA for terms. Free tier available; Pro features are free with a Pro license.

  • Contact us
  • Jobs
  • Privacy
  • Manage cookies
  • Terms of use
  • Trademarks
  • Your Privacy Choices
  • Consumer Health Privacy
© 2026 Microsoft