Orgbench

Product updates

What changed in Orgbench, newest first.

2026-10-28 · 0.1.5

Orgbench 0.1.5

Released 2026-10-28 for IntelliJ IDEA and VS Code. This release covers everything that changed since 0.1.4, the previous public release.

Orgbench 0.1.5 takes Revenue Cloud deployments to production orgs: one Deploy moves the metadata, the product bundles and the constraint models in phases, and a pricing procedure version travels together with the decision tables it reads. Lightning pages, report types and context definitions can now be merged element by element, like page layouts, and the mode is chosen for each document. Rows the target did not accept can be deployed again from the results screen, and the Target health check lets you choose the right record when the target holds duplicates. As before, everything runs on your machine, by default over your own Salesforce CLI; your metadata leaves it only if you turn on Describe differences with Claude Code.

Highlights

  • Production deployments in phases. Against a production org Orgbench offers Validate and Deploy, with a Deployment plan above the buttons. Deploy sends the metadata as one atomic deployment, and transfers product bundles and constraint models only after it succeeded.
  • Pricing procedure versions with their decision tables. One deployment moves a version together with the decision tables it reads, in every deploy mode. A decision table active in both the source and the target is deactivated for the deployment and activated again after it, and the version is activated after its tables; Validate only activates nothing.
  • Element-level merge for more documents. Lightning pages (fields, components and page assignments), report types (columns) and context definitions (new elements only) join page layouts. An Elements checkbox next to each document on the selection screen decides its mode.
  • Re-Deploy from the results screen. Check the rows the target did not accept and deploy them again in the same mode, without a new comparison.
  • Duplicates in the target, resolved on screen. When a bundle record matches several records of the target, the Target health check lets you choose the one the deployment updates. Check target checks the target's references before any comparison, and changes nothing.
  • Open the org in your browser. An icon next to each org opens it, and a Deployment Status link follows a running deployment in Setup. The progress line numbers the packages of a deployment: Deploying the package — 2 of 3.
  • Describe differences with Claude Code. An optional, off-by-default row menu item hands the two versions of one Flow, Apex class or Apex trigger to your own local Claude Code, which sends them to the model provider it is set up for, and shows its plain-English account of the differences.

Deploying to a production org

  • No Best Effort against production. The last step offers Validate and Deploy only. A Deployment plan above the buttons names the steps Deploy will take for the rows checked right now.

  • Deploy runs in phases, and a phase starts only after the previous one succeeded:

    1. the metadata, including the definitions of the selected constraint models and the permission changes, as one atomic Metadata API deployment (several when Salesforce needs them, see below), followed by activating the decision tables and pricing procedure versions it sent inactive;
    2. the Target health check fix, if you chose it, and then the product bundles as records;
    3. the tags, constraint model text and activation of each selected constraint model.

    A row whose phase did not start says why. Once the cause is fixed, Re-Deploy finishes it.

  • Validate checks the metadata phase only and changes nothing. Quick Deploy after it runs the metadata from the validated job and then the remaining phases.

  • Fix during Deploy. Against production the Target health check button is called Fix during Deploy and deletes nothing at once. The marked findings are deleted inside Deploy (or the Quick Deploy of a validation), after the metadata succeeded and before the records are transferred. That deletion cannot be undone, and the screen says so before you press the button.

  • A target whose type Orgbench could not confirm still receives no records.

Pricing procedures and decision tables

  • A version and the tables it reads, in one deployment. A decision table active in both the source and the target travels as inactive and is activated again after its row succeeded. The version is activated after its tables, and only when every table of the deployment that it reads is active; otherwise its row names the table. Validate only rewrites the statuses without activating anything, and a Quick Deploy of that validation activates as Deploy would.
  • Several deployments when Salesforce needs them. A decision table the deployment rewrites to inactive goes in a deployment of its own whenever the selection carries any other row, and is activated again right after it (except in Validate only). A pricing recipe next to a procedure version also goes on its own, and the procedure versions go last. The review screen names what goes in each deployment and says that an earlier one stays in the target if a later one is refused.
  • Removing an input column of a decision table. Salesforce refuses that while an active procedure version of the target reads the table. The review row names the column and the versions that read it, and Deploy first asks Switch off procedure versions?. On your confirmation those versions are switched off only for the table's own deployment and then switched on again by the running plugin. The confirmation names the expected window — about 15 seconds per table in a sandbox and about a minute in production, longer for each further version. Keep the IDE or VS Code open meanwhile: closing or reloading it then can leave a version switched off. A version is switched off only when Salesforce will switch it on again, and never for a managed package. Validate switches no version: the table is validated as it is, and its row says so.
  • An existing version is never changed. A procedure version that already exists in an org target and differs from the source's cannot be selected. Its row says what to do: clone the version in the source and deploy the clone. A git target is not affected.
  • Definitions travel as shells. A procedure definition deployed together with a selected version of it is sent without its nested versions, so the target keeps its own versions. This also holds when the definition differs from the target's outside its versions. A definition sent whole, without a selected version of it, leaves out the nested versions the target already has and names them on its row.
  • Safer activation. A constraint model's version is activated only when its constraint model text reached the target. When a new version cannot be activated after the previous one was deactivated, the previous one is activated again. When an activation call answers with an error, Orgbench reads the target's versions again before deciding what to do next. The results screen counts Not activated: N versions.
  • Versions and statuses on the selection screen. The Expression Set Definitions entry lists each definition's versions with Version and Status columns, the latest on top.

Product Bundles and the Target health check

  • Choose among duplicates. When a bundle record matches several records of the target, the Target health check shows a second table, Duplicates: choose the record this deploy updates. The bundle's records under the chosen one follow it. The other matches stay in the target untouched, and nothing is deleted. A record whose product type differs from the source's cannot be chosen, and its Note says why.
  • A choice never moves silently. A choice that no longer matches is never replaced by another record. It is shown as Choice no longer matches before anything is sent, and the deploy refuses that record. Under a duplicate left without a choice, nothing changes.
  • Check target. Next to Prepare Orgs, Check target checks the target's integrity before any comparison. It reads the 33 Revenue Cloud registry objects of the target, needs no source, and writes and deletes nothing. The findings list the broken references, with links to the records.
  • When an object cannot be found in an org, the message names the likely causes — the feature is not licensed or not turned on, or the Salesforce CLI user cannot access it — and what to do.

Element-level merge

  • Whether a page layout, Lightning page, report type or context definition is compared element by element is now decided for each document, by an Elements checkbox next to it on the selection screen. The Element-level merge setting is the starting value for a component you tick.
  • Report Types can be merged column by column. A new column goes after its nearest neighbour from the source, and columns and sections that exist only in the target are never touched.
  • Lightning Pages can be merged element by element: Dynamic Forms fields and components, and the page's assignments to apps, objects, record types and profiles. Each element is a row you can select. When Dynamic Forms would replace the Record Detail component of the target page, the row says so before you deploy.
  • Context Definitions can be merged element by element. New nodes, attributes, tags and mappings are inserted into a fresh copy of the target's definition, and nothing in it is changed or removed. In both modes, when the target's definition is behind the source's, the row says beforehand that Salesforce's own sync will run and, when both orgs are on the same release, lists what it will add, change and remove.

Applications and their dependencies

  • An application brings what it needs. Checking a custom application also checks the new Lightning pages it assigns or uses as its utility bar, its new custom tabs and the new record types its page assignments name. A tab of a new custom object also checks that object. Every one of those checks is visible and can be removed.
  • Applications that the target accepts. A whole custom application sent to an org target leaves out the page assignments of profiles the target does not have, and sends an assignment the source repeats identically only once. The row names both changes.
  • Managed package applications. They are now read by name. A page assignment inside one is shown, but cannot be selected, and its row says how to assign the page in the target.
  • Person account record types. Page assignments to them are matched under the names Salesforce uses in each place. When the target lacks one, the row says what to do: turn person accounts on in the target, or create the record type there.

Results, Re-Deploy and New Comparison

  • Re-Deploy. Check the Failed and Not Attempted rows on the results screen and deploy them again in the same mode, with the tests chosen for that deployment. A row the deployment already changed in the target cannot be checked, and its tooltip says why.
  • New Comparison keeps your marks. Rows, permission containers and Apex tests are carried to the next comparison, as if the session had been exported and imported.
  • Rows with an error are listed first. Copying the details (Copy in IntelliJ, Copy details in VS Code) takes every component row, and only the permission rows that change the target or were meant to.
  • Validate only says what a deployment would do, and Quick Deploy results carry the notes of their validation.

Everyday workflow

  • Selected components. The selection screen opens on one table of everything you selected in the session, of every type.
  • Diff window. The target is shown on the left and the source on the right by default. The Diff pane order setting (orgbench.diffPaneOrder in VS Code) swaps them: Target left, source right (targetLeft) or Source left, target right (sourceLeft).
  • Faster comparisons. With two orgs, the target is retrieved in parallel with the source. Dependencies are followed only for the components your selection needs, and the progress line names each round.
  • Read orgs through. A new setting (orgbench.orgChannel in VS Code) chooses how Orgbench reads an org and sends the record writes of a bundle or model transfer: Salesforce CLI (sf) (cli), the default and the 0.1.4 behavior, or Salesforce API (faster) (api), which calls the APIs directly over HTTPS with the session the Salesforce CLI holds. That session is kept in memory only, and never reaches a log, a copy, a session file or the disk.
  • Fewer false differences. Formatting of the XML no longer counts as a difference for any document. Values that each org keeps for itself, such as the decision table IDs in procedure steps or the release version of a context definition, and the order of repeated blocks that Salesforce changes when it saves, are not reported either. The diff window still shows those values; for decision tables and context definitions it lays the target out in the source's order and says so in the title of the target pane.
  • Custom fields are compared as whole documents. A difference in a description, help text, picklist values or the required flag now shows as Definition changed.
  • Selected rows hidden by a filter are announced next to the deploy buttons, with a Show them link.
  • Open in browser and Deployment Status. Both run the Salesforce CLI's own sf org open. Orgbench never reads or logs its output, which carries a login URL with a session token.
  • Describe differences with Claude Code. Turn on the setting (orgbench.describeWithClaudeCode in VS Code), then right-click a Flow, Apex class or Apex trigger row with status Update. Only the two versions of that one component, as the diff window shows them, are handed to your own local claude -p, which sends them to the model provider it is set up for (Anthropic by default). Nothing is sent until you choose the item, and the prompt and the answer never reach a log.

Permissions

  • Permission Set repair mode (Best Effort). A new setting (orgbench.permissionSetRepairMode in VS Code) decides how Best Effort treats a Permission Set row against an org: Off (OFF) sends the document as is, with no retry; As now — trim and retry (up to 3) (TRIM_AND_RETRY), the default and the 0.1.4 behavior, trims it by what the target reports and retries up to three times; Target confirmed (TARGET_CONFIRMED) sends it as is first and retries only what the target named, up to four times.
  • History tracking stays with the target. The history and feed tracking settings of custom fields and custom objects no longer travel. An Update keeps the target's settings, an Add is created with tracking off, and the row says when the source's setting differs.
  • A field that the Salesforce CLI user cannot see is no longer trimmed from a Permission Set, Profile or Context Definition.

Git repositories

  • Deploying into a git repository now passes file paths to git on standard input, so very large deployments no longer meet the command-line length limit. This needs git 2.25 or later; an older git is detected before anything is written. Comparing against a repository needs git, but not this version.
  • Before the first write, a deployment refuses a destination whose folder is a symbolic link or a file, and a path the repository ignores. Nothing is written then, and the message says what to change.
  • A second deployment of the same session into a new + branch adds one more commit to it. A + name that already belongs to another branch is refused, and so is a write after the checked-out branch was switched.
  • A branch whose name starts with - is refused before git can read it as an option, and the message gives the command to rename it.

Changes in behavior since 0.1.4

  • No Best Effort against production, and records there through Deploy. The Allow Best Effort against production (Revenue Cloud) setting (orgbench.allowBestEffortOnProduction) was removed. In 0.1.4, records reached a production org only through Best Effort with that setting on. Now Deploy transfers product bundles and constraint models there as records and switches active versions, in phases (see above).
  • Deploy and Validate now handle pricing procedure versions too. In 0.1.4 only Best Effort sent a version that is active in the source as inactive and then switched the target's active version. Now, against an org whose type Orgbench confirmed, production included, every deploy mode sends such a version as inactive when the target runs another version as active; Deploy and Best Effort then switch the active version, and Validate only activates nothing. A decision table active in both the source and the target also travels as inactive in every mode and, except in Validate only, is activated again right after its deployment; one the source has inactive stays inactive, as in the source, and the review screen says so.
  • Existing expression set versions are not updated against an org target. Clone the version in the source and deploy the clone.
  • Data Cloud is not supported. The Marketing & Data Cloud category is no longer offered. Its four types — Analytics Dashboard, Analytics Visualization, Analytics Workspace and External Data Connector — left the type list. Data Cloud has its own way to move between orgs (Data Kits and Data Cloud packages). A saved setting that names the category still works; it just adds no types.
  • The diff window shows the target on the left by default. Set Diff pane order to Source left, target right (sourceLeft) for the old layout.
  • The selection screen opens on Selected components, with no metadata type picked.
  • Page Layouts became Element-level merge. In VS Code, orgbench.elementMode replaces orgbench.layoutMode, which is still read while the new key is not set. The setting now gives only the starting value of each document's Elements checkbox.
  • History tracking settings no longer travel, and a managed or standard field that used to be a Tracking only row is now a Permissions only row.
  • Custom fields are compared as whole documents, so more of their changes show as Definition changed.
  • Two new settings keep the 0.1.4 behavior by default: Permission Set repair mode is TRIM_AND_RETRY (As now — trim and retry (up to 3) in IntelliJ), and Read orgs through is Salesforce CLI (sf) (cli).
  • Deploying into a git repository needs git 2.25 or later. Comparing against a repository needs git, but not this version; an older git is detected before anything is written.
  • Tables. On the selection, container and results screens, the API Name column comes before Label. On the results screen, rows with an error come first.

Fixes

  • Comparison. Decision tables, pricing procedure versions and context definitions no longer show as Update when they differ only in values each org writes for itself. A merge into a target with Windows line endings now keeps the target's line breaks. Orgbench no longer fails to start the Salesforce CLI when FORCE_COLOR is set in the environment.
  • Context Definitions. A node mapping that the mappings of its child nodes need is no longer cut. References to fields the Salesforce CLI user cannot access are kept.
  • Sign-in and errors. An expired sign-in names the org by the alias you picked and points to the + button. A session the org rejects right after the Salesforce CLI refreshed it suggests switching Read orgs through to Salesforce CLI. A failed retrieve shows the cause the Salesforce CLI gave, and the error screen's heading names the cause when Orgbench knows it.
  • Diagnostics. The sanitizer now also hides tokens with a prefixed name (such as sfAccessToken), a bare Bearer token, a bare Salesforce session ID, a JWT and a force:// auth URL.
  • Results. The line explaining why Quick Deploy is missing is shown again when Salesforce answered 0 tests run.
  • IntelliJ. Compatibility fixes for IntelliJ platform 2026.3.
  • VS Code. Importing a session restores the selection of its rows, and while an operation runs the table of differences ignores a double-click.

Requirements

  • IntelliJ: IntelliJ IDEA 2024.2 or newer, or another IDE built on the IntelliJ platform.
  • VS Code: VS Code 1.85 or newer. Install the VSIX for your platform: orgbench-darwin-arm64.vsix, orgbench-darwin-x64.vsix, orgbench-win32-x64.vsix or orgbench-linux-x64.vsix.
  • Platforms: macOS (Apple Silicon or Intel), Windows x64 or Linux x64. Linux on ARM is not supported.
  • Salesforce CLI (sf), installed and signed in to at least one org under an alias.
  • git 2.25 or later, only for deploying into a local git repository. Comparing against a repository needs git, but not this version.
  • Claude Code (claude), installed and signed in, only for Describe differences with Claude Code.
  • Product Bundles and Constraint Models need two orgs on Metadata API 67.0 or newer.
  • Licensing: Orgbench is free during early access, and nothing is gated today. License checks are fully offline.

All files are on the downloads page. The IntelliJ and VS Code documentation cover the new production deployment, element-level merge and duplicate handling in full.

2026-09-25 · 0.1.4

Orgbench 0.1.4

Released 2026-09-25 for IntelliJ IDEA and VS Code. This release covers everything that changed since 0.1.1, the previous public release.

Orgbench 0.1.4 brings Revenue Cloud into the compare-and-deploy workflow: pricing metadata with its dependencies selected for you, and Product Bundles and Constraint Models transferred between two orgs as records. Permission Sets, Permission Set Groups and Profiles are now their own comparison types, Best Effort recovers from more of the rejections Salesforce answers with, and Linux x64 is now supported. As before, everything runs locally over your own Salesforce CLI.

Highlights

  • Revenue Cloud pricing metadata. Context Definitions, Decision Tables, pricing procedure versions, Pricing Recipes and eight more pricing types can be compared and deployed. Check the top of a chain, such as a Pricing Recipe, and the components it needs are checked for you. Every one of those checks is visible and can be removed.
  • Product Bundles and Constraint Models between two orgs. Both are compared as documents built from the org's records and deployed in Best Effort. Prepare Orgs sets up the external keys used to match records between the orgs. The Target health check screen shows what in the target would block the transfer before anything is sent.
  • Permission Sets, Permission Set Groups and Profiles as their own types. They are compared and deployed as whole documents. In Best Effort a Permission Set Group document is trimmed to what the target knows; a Permission Set or Profile document is trimmed the same way when both source and target are orgs. The row's message names what was left out.
  • Best Effort that recovers more often. It makes a limited number of retries for known rejections. A new setting lets you use Best Effort against a production org if you choose to (see Allow Best Effort against production below).
  • Linux x64. It is the fourth supported platform in both editors.
  • Less clicking. Orgbench remembers the source and target aliases you used last. A folder can be made into a git target with one button. In IntelliJ, pressing a deploy button starts the deployment right away.

Revenue Cloud pricing metadata

Turn on the Revenue Cloud category in the settings to use it. It is off by default. In IntelliJ it is under Settings | Tools | Orgbench | Metadata categories. In VS Code, add RevenueCloud to orgbench.metadataCategories.

  • Twelve pricing metadata types. Context Definition, Decision Table, Decision Table Dataset Link, Decision Matrix Definition and its versions, Expression Set Definitions, Expression Set Message Token, Expression Set Object Alias, Pricing Action Parameters, Pricing Recipe, Procedure Plan Definition and Product Attribute Set.

  • Pricing procedures travel as versions. The Expression Set Definitions entry lists pricing procedure versions. If the target doesn't have the procedure's definition yet, checking a version also checks that definition. The definition is then sent without its other versions, so an org target gets only the versions you checked, and the row's message says so.

  • Dependencies are checked for you without the Tooling API. Orgbench reads each source document to find what it references:

    • a Pricing Recipe checks its pricing procedure and decision tables;
    • a pricing procedure checks the decision tables its lookup steps name and its context definition;
    • a Context Definition checks the custom fields and objects it reads data from, and the other context definitions it maps to;
    • a Decision Table checks its fields and source object;
    • a Dataset Link checks its table and source object.

    With an org as the source, the comparison also fetches those referenced components. With a git source, the dependencies are checked only among rows already in the table.

  • Context Definitions fit the target. With an org on both sides, entries that read fields the target doesn't have are left out when a Context Definition is deployed, and the row's message lists them. When the source org runs a newer Salesforce release than the target, the document's release version is changed to the target's. Deploying a context always creates a new version and never deletes or deactivates an existing one.

  • Pricing procedure activation (Best Effort, against a target that accepts records). A version can be active in the source while the target runs a different version as active. In that case the version is sent as inactive. Once it deploys, Orgbench deactivates the target's old version and activates the new one, and the row's message says what happened. In Validate and Deploy (all or nothing), nothing is rewritten or activated. The target must be confirmed non-production, or production with Allow Best Effort against production on when Compare was pressed.

  • Older target releases. Below Metadata API 68.0, a usageSubtype or pricingUsageSubType value of RevenueCloud is removed from the document before it is sent, and the row's message names what was removed.

Product Bundles and Constraint Models

The Revenue Cloud category also lists Product Bundle and Constraint Model. Their rows are records, not metadata files. They are compared between two orgs only, never with a git repository, and need Metadata API 67.0 or newer.

  • What you compare. Orgbench builds a document for each bundle from its catalog records. The document includes classifications, component groups, related components, child products, selling model options and price book entries. A model's document includes its definition, its versions, the CML text of each version and its tags. Open the diff to see the document.

  • Dependencies. Checking a bundle adds the constraint models that tag it to the comparison. Those models are checked if they have an active version in the source. A bundle also checks any child product that is itself a bundle.

  • Deploying. When a record row is checked, only Best Effort is offered, because records have no dry run and cannot be rolled back. Bundle records are sent through the REST API before the metadata package, layer by layer. Records in the target are matched by external key first and then by natural identity (a name, a code or the parent chain). The model is deployed as its definition, followed by its tags, its CML and the activation of its source-active version. The Metadata API package itself never switches the target's active version: every version is sent inactive, and the version the target currently runs as active is left out of the package. After the tags and CML, Orgbench activates the version that is active in the source, deactivating the target's current one first, and the row's message says what happened.

  • Prepare Orgs. The Revenue Cloud category also lists 33 configuration objects. Prepare Orgs writes a shared external key on their records in both orgs, so records can be matched between the orgs. It is shown on the selection screen when an enabled category contains records, and it asks you to confirm, naming both orgs, before it runs. It writes only the key values, and when it creates a new key field, it gives your own profile access to that field. It deletes nothing, and running it again changes nothing. It is the only operation in Orgbench that writes to the source org. Once both orgs already have their keys, the button shrinks to a refresh icon.

  • Target health check. Before a Product Bundle deploys, Orgbench reads the target and makes the same decisions the transfer will make. If it finds nothing, the screen does not appear. Otherwise it lists three kinds of findings, before anything is sent:

    • target records that the target will refuse to save;
    • duplicate records the transfer can't choose between;
    • missing relationship types, selling models or price books.

    Each finding says what to do. A Record Id column links to each record in the target org. The buttons are Fix, Deploy without fixing, Re-check and Cancel.

  • What Fix deletes. Fix deletes only the findings you left checked. They can only be records of three leaf objects: product related components, product selling model options and price book entries. Orgbench deletes them by the record IDs it read during the check. Deleting is immediate and cannot be undone: the records are created anew only by the deployment that follows, so if you stop before it runs, they stay deleted. Constraint model tags that address a deleted record are deleted by Salesforce with it; they come back only for the models deployed in the same run, and each finding says how many such tags it carries. Orgbench then checks the target again, and you press Deploy yourself. Apart from Fix, transferring records never deletes anything in the target: not a record, a tag or a version.

  • Production. By default, records are never sent to an org Orgbench recognizes as production, and never to a target whose type it could not confirm.

Permission Sets, Permission Set Groups and Profiles

These types are in the Security & Sharing category.

  • Permission Set. The whole document is sent, and it replaces the permission set in the target.
  • Permission Set Group. Before it is sent, the group is trimmed to the permission sets the target has or that this deployment creates, and the row's message names what was left out. Checking a group also checks the permission sets it needs that the target doesn't have yet. A set the target already has is never redeployed this way.
  • Profile. The document is merged into the target profile rather than replacing it. You can create a custom profile. A standard profile can't be added and its row says why.
  • Trimmed to the target in Best Effort, org to org. With an org on both sides, a Permission Set or Profile document drops the user permissions, and the references to fields, objects, classes, pages, tabs and other components, that the target doesn't know. Anything sent in the same deployment is never cut. The row's message lists what was left out.
  • The permission transfer. A container that is deployed by its own comparison row is unavailable on the Select Permission Containers screen, and so is a new permission set whose license the target lacks. The reason is shown on the row. A permission set that the transfer creates now carries the source's description and license. The container screen appears only when a checked row actually carries permissions to transfer.

Best Effort

  • Limited retries of the affected rows. Best Effort against an org now retries after specific rejections, resending only the rejected rows:
    • a Permission Set Group, once;
    • a Context Definition, up to three times;
    • a Permission Set, up to three times;
    • a Profile, up to five times;
    • rows that fail with only Salesforce's generic "An unexpected error occurred", once, together.
  • Retry rows alone. The new setting Retry rows alone after a Salesforce unexpected error (Best Effort) is off by default. Turn it on to deploy each row still failing with the generic error once more on its own. With it off, the row's message names the setting.
  • Allow Best Effort against production. This new setting — Allow Best Effort against production (Revenue Cloud) in IntelliJ, orgbench.allowBestEffortOnProduction in VS Code — is off by default. It makes Best Effort, and the record transfer, available against an org Orgbench recognizes as production. It also lets Orgbench switch the active version of a deployed pricing procedure or Constraint Model in that org. Orgbench reads it when you press Compare. Partial deployments can leave data incomplete, so use it with care.
  • Object children fail together. Salesforce deploys an object's fields and children as one component. When it rejects one of them, the others are now reported as failed as well, with the reason, instead of as succeeded.

Everyday workflow

  • Remembered aliases. The source and target aliases you picked last are selected again the next time Orgbench opens. Only aliases are remembered, and only on this machine. A git repository is not remembered.
  • Initialize a git repository. If the folder you chose as a git target is not a repository yet, an Initialize a Git repository here button appears. Orgbench asks you to confirm, naming the full path, and then runs only git init: no commit, no branch and no push.
  • Pasted repository paths. The path field now accepts surrounding quotes, a leading ~ and invisible characters copied along with the path. If git itself can't run on the machine, the message says so and explains how to fix it.
  • Reload Orgs also reloads the component list of the type on screen.
  • Metadata API version. A comparison and its deployment now use the lower of the two orgs' Metadata API versions, so a type that only a newer release offers can be fetched.
  • Editing large documents. In the diff view you can edit a metadata document of up to 16 MiB. Code bodies are still limited to 1,000,000 characters.
  • Dependency cascades for more metadata. A custom field checks its global value set. A lookup field checks the object it points to and the fields its filter names. A roll-up summary field checks the fields it summarizes and filters on. A custom metadata record checks its type and fields.

Changes in behavior since 0.1.1

  • The default permission transfer mode is now Additive permissions in both editors. It was Do not transfer permissions. If you want to keep Do not transfer permissions, check the setting after upgrading: a mode you never changed from the old default follows the new default.
  • 27 metadata types were removed from the type list. They either cannot be transferred between orgs or are meaningless to transfer:
    • Auth Providers, External Auth Identity Providers, External Data Sources and SAML SSO Configs;
    • Inbound Network Connections and Outbound Network Connections;
    • Person Account Owner Power Users, My Domain Discoverable Logins, Profile Password Policies and Profile Session Settings;
    • Apex Email Notifications and Feature Parameter Booleans, Dates and Integers;
    • Lightning Bolts, Networks and Digital Experience Configs;
    • Call Ctr Agent Fav Trfr Dests, Service AI Setup Definitions, Service AI Setup Fields, Conversation Vendor Infos and Conversation Channel Definitions;
    • UI Preview Message Tab Defs, Wave Analytic Asset Collections, Analytic Snapshots, Translations and Custom Indexes.
  • Analytics dashboards, visualizations and workspaces, and External Data Connectors, moved to Marketing & Data Cloud. This category now appears in the settings and is off by default. If you used those types, turn it on.
  • Industries is now part of Revenue Cloud. A saved Industries category is read as Revenue Cloud.
  • IntelliJ: the Confirm Deployment dialog is gone. Pressing Validate, Deploy or Best Effort starts the deployment right away, without a confirmation dialog. VS Code already worked this way.
  • The Select Permission Containers screen opens only when it has something to do. A transfer mode must be on, and at least one checked row must carry permissions. Otherwise the screen before it is the last step.

Fixes

  • Transferring permissions from a git repository source into an org target no longer stops with an internal error.
  • When loading the component list fails, the error now shows Salesforce's reason instead of a CLI "update available" notice.
  • Unnamed fields and children of an object whose sibling Salesforce rejected are no longer reported as succeeded (see Best Effort).

Requirements

  • IntelliJ: IntelliJ IDEA 2024.2 or newer, or another IDE built on the IntelliJ platform.
  • VS Code: VS Code 1.85 or newer. Install the VSIX for your platform: orgbench-darwin-arm64.vsix, orgbench-darwin-x64.vsix, orgbench-win32-x64.vsix or orgbench-linux-x64.vsix.
  • Platforms: macOS (Apple Silicon or Intel), Windows x64 or Linux x64. Linux on ARM is not supported.
  • Salesforce CLI (sf), installed and signed in to at least one org under an alias.
  • Product Bundles and Constraint Models need two orgs on Metadata API 67.0 or newer.
  • Licensing: Orgbench is free during early access, and nothing is gated today. License checks are fully offline.

All files are on the downloads page. The IntelliJ and VS Code documentation cover the new Revenue Cloud and permission transfer behavior in full.

2026-09-07

Linux x64

The VS Code extension 0.1.2 is now available as orgbench-linux-x64.vsix alongside the macOS and Windows builds, and the IntelliJ plugin 0.1.1 bundle carries the Linux x64 core binary. The Linux core is statically linked against musl, so it does not depend on a particular system libc version. Linux on ARM has no build.

All files are on the downloads page. The VS Code documentation describes the Linux install path.

2026-08-21

Permission transfer, session export, editable diffs

The IntelliJ plugin and the VS Code extension picked up a set of improvements this week.

  • Permission transfer grew from field-level security into six kinds of permissions: fields, objects (including View All Fields), Apex classes, Visualforce pages, tab visibility and record type visibility. Screens and labels are renamed from FLS to Permissions. Permission containers now show their Setup label and are matched by Id and metadata fullName, so profiles whose Setup name differs from the metadata name — Standard User versus Standard — no longer drop out of the list.
  • Session export and import replace the package.xml manifest buttons. Export Session writes a JSON scenario with both endpoints, the manifest, checked rows, the permission mode, test classes, containers and the deploy mode; Import Session pre-fills the wizard from such a file. Manifest support itself stays in the core.
  • Editing in the difference view extends from Apex classes and triggers to any single-file component: Visualforce pages, objects, fields, flows, layouts and others. Bundles and container files stay read-only.
  • Best-effort deployments send the whole selection as one package: components Salesforce accepted stay deployed, rejected ones are the only Failed rows. Names, methods and messages of failed Apex tests are shown in every deploy mode.
  • Unmanaged children of managed-package objects — fields, list views, validation rules and others — are compared and deployed; the packaged object itself still is not.
  • The Custom Object comparison schema grew from 8 to 20 attributes, so an object created in the target keeps the capabilities enabled on the source, and its fields are no longer rejected because of disabled feeds.

The IntelliJ and VS Code documentation pages reflect the changes.

2026-08-07 · 0.1.1

Orgbench 0.1.1

Both clients ship a bundled native core for macOS arm64, macOS x64 and Windows x64. Linux is planned.