EPM Workbench

A Modern IDE Experience for developing EPM Rules.

Autocomplete that knows your outline · mistakes flagged as you type · push, deploy, and run without leaving the editor

Website · Docs · Pricing · Issues

Calculation Manager hasn't changed in 15 years

You've felt it every time that text box loads. Your Planning, PBCS/EPBCS, FCCS, and Essbase rules deserve a real editor. EPM Workbench brings them to VS Code as ordinary files, with real intelligence behind them:

A Modern IDE Experience

Real intelligence across both Groovy and calc script: completion, error checking, hover docs, and one-key formatting, with whole-application awareness that reads across every rule, template, and script.

Groovy: run-time prompts and the EPM Groovy API complete as you type:

Calc Script: member names from your outline, completed and validated live:

%Template expansion knows your whole application. Hover a %Template call and read the resolved template body inline, without opening a file:

Everything the editor knows about your application becomes completion:

API Docs & Hover Annotations baked right in

The full EPM Groovy API reference lives inside the editor. No browser, no PDF, no tab-switching.

• Hover any EPM Groovy API call for inline documentation
• Full searchable reference docked in the side panel
• Right-click any type to jump straight to its docs
• Bundled with the extension, so it works completely offline

Bring your own AI

Rules are plain .groovy and .csc files in a folder you own, so Claude Code, Codex, GitHub Copilot, and any other AI tool and harness read and edit them directly.

• Your existing subscriptions and policies apply. AI runs through each provider's own extension, never through us.
• Application context comes free. EPM Workbench is native VS Code, so your assistant sees the same rules, templates, and dimensions you do.
• File-system access means real review. It can scan whatever it needs to assess a change, across the whole application.
• Nothing is locked in a proprietary store. Your whole modern toolchain applies.

Dimensions you can actually search

Browsing an outline should feel instant, and in the Planning UI it never does. We spent a considerable amount of time making this viewer as fast and useful as we could get it. The recording above is a real 1.1-million-member dimension:

• Search at typing speed across the full outline: names and aliases, a million members and more, no spinners
• Expand, collapse, and scroll hierarchies with zero lag and no page reloads
• Filter by member properties like storage, formulas, and UDAs to find outline issues fast
• Member details in a click: properties, per-cube settings, and formulas beside the tree
• Artifact browser lists every rule, template, script, and variable in the Pod

Sync with your Pod Full

Work locally, then send it back when you're ready:

• Pull the Pod's current rules down into your folder
• Push your edits back to Calculation Manager
• Deploy into the Planning application
• Execute, and the job log comes straight back to a panel beside your code: Groovy log() output, calc errors, timings. No hunting through the EPM Jobs page.
• Change detection warns you before you overwrite someone else's edit

Or work fully offline Offline: import a migration snapshot (LCM zip) from disk and get the whole workspace with zero connectivity. Every rule as a file, dimensions, member completion, validation. Built for air-gapped and regulated sites.

Either way, all your storage is local. Your files, optionally your git, then deploy straight to your Pod. There is no server of ours in the path, and rules are never proxied through us.

One workspace, many Pods

Dev, test, prod, or different clients entirely, side by side in one workspace.

• Switch Pods in a click. Each keeps its own folder, credentials, and settings.
• Sign in your way: service account, OAuth through your own SSO/MFA, or fully offline
• Credentials stay in VS Code's encrypted secret store: never in project files, never committed, never sent anywhere except your Pod
• Shared library folders: reusable scripts and templates, backed by a git repo, copied into any Pod in a click

Free vs paid

Free to install. The Free tier never expires, and needs no key or account.

A seat is one person, not one machine. The 30-day trial takes no payment up front, and if a subscription lapses you drop back to Free rather than losing access. Every file on your disk stays yours.

Pricing and seats: https://www.epmworkbench.com/pricing

Getting started

On Free: install the extension, click the EPM Workbench icon in the Activity Bar, and choose Create New Library Folder in the Pod picker. That gives your rules a home: Rules, Templates, and Scripts folders ready for your .groovy and .csc files, with completion, error checking, formatting, and the API reference on whatever you open. Only the rule you have open is used for single-file language intelligence; the full folder corpus is not.

On a paid tier:

1. Install the extension and open a folder to work in.
2. Add a Pod with your Pod URL and application name.
3. Sign in with a service account or OAuth, or choose Offline and import a snapshot.
4. Pull to bring the rules down as files. Edit, format, search.
5. Push, Deploy, or Execute when you're ready.

Needs VS Code 1.92+. For Groovy intelligence, EPM Workbench first runs its bundled language-service JAR locally when it finds Java 21+; Oracle Java and compatible open-source OpenJDK distributions both work. You can select the exact java.exe (Windows) or java (macOS/Linux) under EPM Workbench: Select Java Runtime. The EPM Groovy status lets you choose auto (local-first with hosted fallback, the default), local (local-only), or hosted (connect directly without probing Java).

Live EPM features need an Oracle EPM Cloud Pod and an account with Calculation Manager and migration access; Offline needs only a snapshot on disk.

Full guide: https://www.epmworkbench.com/docs/getting-started/install

• "Rules" means Groovy rules, script rules, and calc scripts. Graphical rules are visible in the artifact browser but not editable here.
• Run-time prompt management covers the basics: strings, members, numbers, and the other simple types. Complex prompt types (Smart Lists and the like) are still a work in progress, and managing template DTPs is not supported in this version.
• Our error checking is a best effort, not Oracle's compiler. It catches a great deal, but it will occasionally flag something Oracle accepts or miss something Oracle rejects. Deploy is still the final word, and we fix these as we find them.
• Groovy intelligence runs locally when Java 21+ is available. Otherwise, the hosted fallback processes and discards open rule text; on Offline and Full it also receives the active Pod's rule corpus for whole-application validation and %Template expansion. Calc-script help always runs on your machine. See privacy for what is sent and how to turn it off.

• Website: https://www.epmworkbench.com
• Getting started: https://www.epmworkbench.com/docs/getting-started/install
• Working offline: https://www.epmworkbench.com/docs/guides/offline-mode
• Seat keys and licensing: https://www.epmworkbench.com/docs/guides/seat-keys
• Privacy and telemetry: https://www.epmworkbench.com/docs/reference/privacy (usage and error telemetry respects VS Code's telemetry.telemetryLevel setting)
• Report a bug or request a feature: https://github.com/rsmiller213/epm-workbench-issues/issues
• Report a security issue: https://github.com/rsmiller213/epm-workbench-issues/security/advisories/new

_{EPM Workbench is an independent product, not affiliated with, endorsed by, or sponsored by Oracle. Oracle, Oracle EPM, Essbase, Hyperion, and Smart View are trademarks of Oracle Corporation.}