Browse the Knowledge Hub211 resources
LoadRunner review: pricing, alternatives and tutorial
LoadRunner is OpenText’s commercial performance testing family, now sold as Professional, Enterprise and Core Performance Engineering. You record or write virtual user scripts in VuGen, run them from a Controller across load generators, and study the results in Analysis. Its distinguishing strength is protocol coverage: over 180 protocols and technologies, from Web HTTP/HTML to SAP GUI, Citrix and mainframe terminals.
QAble runs this tool on client engagements. The assessment below is from that experience.
- last reviewed
- 13 October 2026
- version covered
- Professional Performance Engineering 26.3 (LoadRunner Professional)
- licence
- Commercial
At a glance
LoadRunner at a glance
- Vendor
- OpenText
- Category
- Performance testing
- Licence
- Commercial
- Platforms
- Windows, Linux (load generators), Docker (load generators), macOS (DevWeb only)
- Languages
- C, JavaScript, Java, C#, VB .NET
- Integrates with
- Jenkins, Azure DevOps, TeamCity, Enterprise Performance Engineering, Application Quality Management (formerly ALM), JMeter and Gatling scripts
- First released
- 1993
- Version reviewed
- Professional Performance Engineering 26.3 (LoadRunner Professional)
Verdict
Our verdict on LoadRunner
Strengths
- Over 180 protocols, including SAP GUI, Citrix ICA, Oracle NCA, RDP and terminal emulation, which open source tools do not reach
- Design Studio scans recordings and replays for dynamic values and writes the correlation code for you to review
- Goal-oriented scenarios add Vusers until a hits, transactions or response time target is reached
- Analysis merges and compares runs, with SLAs that turn results into a pass or fail
- One Controller runs VuGen, DevWeb, TruClient, JMeter and Gatling scripts in the same scenario
Weaknesses
- Commercial licences priced by Vusers and protocol bundles; the free Community licence stops at 50 Vusers
- VuGen, Controller and Analysis run on Windows only; Linux and Docker are for load generators
- Recorded C scripts are verbose, and correlation breaks whenever the application changes its tokens
- Three product names, two rebrands and old Micro Focus URLs make tutorials hard to match to your version
Best for
Enterprise estates where the load has to be generated over something other than HTTP: SAP GUI, Citrix, Oracle Forms, terminal emulation or remote desktop. No open source tool reaches those protocols in a supported way, and that is usually why LoadRunner is still on the shortlist. It also suits organisations that need one governed tool across many teams, with shared scenarios, SLAs and an Analysis report that business owners already recognise, and teams that want JMeter or Gatling scripts run and reported beside VuGen ones.
Not for
Web and API testing on its own, where JMeter, k6 or Gatling cover the same protocols without a licence and fit a pull request workflow far better. It is also a poor match for teams who want every engineer to run load tests from a laptop on macOS or Linux, since VuGen, Controller and Analysis are Windows applications, and for anyone whose budget cannot absorb Vuser licences that scale with peak concurrency and protocol.
Setup cost
High. Expect to spend the first days on things that have nothing to do with scripting: installing VuGen, Controller and Analysis on Windows, provisioning load generators, installing licences on the Controller machine and confirming the bundles cover every protocol in the plan. Then comes correlation, which is the largest single effort on any stateful application. The free Community licence makes a proof of concept possible without a purchase, but only up to 50 Vusers.
Maintenance burden
Significant, and concentrated in correlation. Every application release can change a token, a hidden field or a session format, and the script fails in ways that only a replay log comparison explains. Design Studio finds many of these again, but someone still has to review its suggestions. Licence administration is a recurring task, and product renames mean plugin names, help URLs and menu labels drift between versions.
Honest limitations
Concurrency is bought, not configured: the Vuser licence is the ceiling, whatever hardware you have. The authoring and execution tools are Windows-only, so CI needs a Windows agent with the product installed. Wlrun, the Controller command line, documents no exit codes, so pipeline gating goes through the Jenkins or Azure DevOps integration and its SLAs. TruClient browser Vusers cost far more load generator capacity than protocol Vusers.
How it works
How LoadRunner works
Four components with separate jobs
LoadRunner splits the work into tools that each do one thing. VuGen, the Virtual User Generator, records traffic and produces a script for one virtual user (a Vuser). Controller builds a scenario from scripts: how many Vusers run each one, on which load generators, on what schedule, with which monitors and SLAs. Load generators are the machines that actually run the Vusers, on Windows, Linux or Docker, either local or in a cloud. Analysis opens the result files afterwards and builds graphs and reports. The split explains much of the experience: scripts are authored and debugged in one place, scaled in another, and judged in a third, so each step has its own settings to get right.
Protocol Vusers replay traffic, not clicks
Most LoadRunner scripts work at the protocol level. VuGen records the requests a client sends, such as HTTP calls, SAP GUI messages or Citrix ICA events, and writes them as function calls; a Web HTTP/HTML script is C by default, with calls such as web_url and web_submit_data. On replay, no browser or client runs: the Vuser sends the same kind of traffic directly. That is why one load generator can run many protocol Vusers, and why the protocol range is so wide. It is also why a script captures only what was on the wire. Client-side rendering and JavaScript timing need TruClient, which drives a real browser and costs far more per Vuser.
Correlation decides whether a script replays
A recording contains values the server generated for that one session: session IDs, CSRF tokens, view state, order numbers. Replaying them verbatim fails, often with a 200 response that hides an error page. Correlation replaces each one with a parameter captured from an earlier response at run time, using web_reg_save_param_ex with left and right boundaries or web_reg_save_param_regexp. The registration call goes before the request whose response contains the value. VuGen’s Design Studio finds candidates three ways: correlation rules during code generation, a record scan, and a replay scan that compares responses after a failed replay. It is not available for DevWeb scripts, where extraction is ordinary JavaScript.
Licences are checked per protocol at run time
Vusers need a licence installed on the Controller machine, and licences come in protocol bundles: Web, Web 2.0, SAP, Remote access, Network, Java and so on, up to an Enterprise Suite that combines them. A multi-protocol Vuser runs only if every protocol in its script is licensed. Licence types include permanent, time-limited, evaluation and VUFD, a Virtual User Flex Day where consumption is the peak number of concurrent Vusers in a 24-hour period. The free Community licence installs with the product and allows 50 Vusers on all protocols except the COM/DCOM, Templates and GUI bundles. Licensing therefore shapes test design: protocol choice and peak concurrency are cost decisions.
One engine, three products, new names
The family is sold in three forms that share VuGen, scripts and protocols. Professional is the desktop suite, with a Controller you run yourself. Enterprise is a web platform for shared projects, load generator pools, timeslots and trend reports across many teams. Core is the SaaS form, with cloud load generators and licences consumed by Vuser or Vuser hour. OpenText has renamed them, as its October 2025 blog post explains: LoadRunner Professional is now OpenText Professional Performance Engineering, LoadRunner Enterprise is Enterprise Performance Engineering, LoadRunner Cloud is Core Performance Engineering, and LoadRunner Developer is Performance Engineering for Developers. OpenText states the tools, scripts and scenarios are unchanged. OpenText ships two releases a year; 26.1 and 26.3 share one help centre.
Strengths
What it does well
Protocols the open source tools do not speak
The licence bundles list SAP GUI, Citrix ICA, Microsoft RDP, Teradici PCoIP, RTE terminal emulation, Oracle NCA, Siebel, Tuxedo, Kafka, MQTT, LDAP, IMAP and more, beside the web protocols. For an ERP rollout or a virtual desktop estate, this is the reason to choose LoadRunner: the alternative is driving those clients through a GUI tool, which does not scale to realistic load.
Correlation suggestions from Design Studio
Design Studio lists the dynamic values it found, marks whether a rule, the record scan or the replay scan found each one, and inserts the extraction code when you accept it. Accepted values can be saved as rules so the next recording of the same application is correlated automatically, which matters on large estates where dozens of scripts share a login and session pattern.
Scenarios that chase a goal
Beside manual scenarios, where you set the Vuser count and schedule, Controller can run goal-oriented scenarios with five goal types: virtual users, pages per minute, hits per second, transactions per second and transaction response time. Controller adds Vusers in batches within a minimum and maximum range until the target is met, and marks the scenario failed if it cannot get there. It answers capacity questions directly.
Real browser timing with TruClient
TruClient records user actions in a real browser as readable steps, with JavaScript or C for custom logic. TruClient 2.0 for Web drives locally installed Chrome, Edge or Firefox (Firefox in beta in 26.1), and 26.3 added Cumulative Layout Shift and Interaction to Next Paint graphs. Use a few TruClient Vusers beside protocol load to see what users experience while the servers are busy.
Analysis that compares and judges runs
Analysis turns a run into graphs for transactions, hits, throughput, errors and monitored server resources. Merged graphs overlay two measures from one run, such as response time against Vusers, and Cross Result graphs compare several runs, which is how regressions between builds are shown. SLAs defined in the scenario give each run a pass or fail, and templates keep reports consistent between runs.
One Controller for several script types
The Web bundles include DevWeb, JMeter and Gatling alongside Web HTTP/HTML, so a team that already has JMeter plans or Gatling simulations can run them from Controller in the same scenario as VuGen scripts and read them in one Analysis report. That helps organisations that standardise on LoadRunner for governance while individual teams keep their own scripting tools.
DevWeb for code-first teams
DevWeb is a JavaScript protocol with its own SDK, working at the HTTP and WebSocket level. Scripts are plain files edited in any IDE, and the standalone Performance Engineering for Developers package runs them on Windows, Linux and macOS. The same script then scales through Controller, Enterprise or Core. Since 26.1 a DevWeb MCP server lets AI assistants record, generate and run scripts.
Pricing
LoadRunner pricing and licensing
LoadRunner is commercial, and OpenText publishes no list prices: you request a quote or buy through a partner. Professional and Enterprise are licensed by Vusers within protocol bundles, so cost follows peak concurrency and the protocols your scripts use, not the number of testers or machines. Core Performance Engineering, the SaaS form, consumes fixed Vuser licences or Vuser hours. A Community licence with 50 Vusers is free for proof of concept and non-production testing, and a free trial needs no credit card.
- Community licence: installed with the product, free of charge, 50 Vusers for every protocol except the COM/DCOM, Templates and GUI bundles. OpenText’s licence bundles overview describes it as for proof of concept or non-production testing.
- Protocol bundles: Web, Web 2.0, Rich internet applications, SAP, Oracle E-Business, Remote access, Remote desktop, Network, Database, Java, .NET, SOA, Mobile and IoT, Development, Templates and GUI, or an Enterprise Suite that combines them. A Vuser needs a licence for every protocol in its script.
- Licence types: permanent, time-limited, evaluation and VUFD (Virtual User Flex Day). VUFDs are consumed by the peak concurrent Vusers in each 24-hour period and generally expire a year after purchase if unused.
- Core Performance Engineering: a VU licence is fixed capacity; a VUH is one Vuser running for one hour, counted over the whole test including ramp-up, ramp-down and pauses, and sold through OpenText or as pay-per-use on AWS Marketplace. Cloud load generator settings can apply a Vuser multiplier.
- Hidden costs: Windows machines for VuGen and Controller, load generator infrastructure, the Mobile Center licence that the free Mobile UI bundle requires, and the engineering time that correlation and licence administration take on every release.
Checked against the vendor’s own pages on 13 October 2026. Pricing changes; confirm on the official site before buying.
Getting started
LoadRunner tutorial: getting started
Setup, step by step
- Request the free trial from OpenText and install the full product on a Windows machine; the Community licence is installed with it.
- In VuGen, create a Web - HTTP/HTML script, start the recorder against a test environment and walk through one short journey.
- Replay the script once with extended logging, then open Design Studio and accept the dynamic values it suggests.
- Wrap each user step in a transaction, replace hard-coded users and URLs with parameters, and replay again until it is clean.
- Open the script in Controller as a manual scenario with a few Vusers on localhost, add an SLA on transaction response time, and run it.
- Open the results in Analysis and check the transaction summary and errors before raising the load.
Install
# Windows only for VuGen, Controller and Analysis.
# 1. Request the free trial at opentext.com and download the installer.
# 2. Run the full installation; the free 50-Vuser Community licence is included.
# 3. Optional: install extra load generators on Windows (OneLG), Linux or Docker.
# Run a saved scenario from the command line on the Controller machine:
wlrun -TestPath C:\scenarios\checkout.lrs -RunA first example
/* Action.c in a Web - HTTP/HTML script (C language) */
Action()
{
/* Register extraction BEFORE the request whose response holds the token */
web_reg_save_param_ex(
"ParamName=CsrfToken",
"LB=name=\"csrf\" value=\"",
"RB=\"",
"NotFound=error",
SEARCH_FILTERS,
"Scope=Body",
LAST);
lr_start_transaction("Open-Login");
web_url("login_page",
"URL={BaseUrl}/login", /* {BaseUrl} comes from a parameter */
"Resource=0",
"RecContentType=text/html",
"Mode=HTML",
LAST);
lr_end_transaction("Open-Login", LR_AUTO);
lr_think_time(3);
/* Fails the step if the text is missing, even on a 200 response */
web_reg_find("Text=Sign out", LAST);
lr_start_transaction("Sign-In");
web_submit_data("sign_in",
"Action={BaseUrl}/login",
"Method=POST",
"Mode=HTML",
ITEMDATA,
"Name=username", "Value={Username}", ENDITEM,
"Name=password", "Value={Password}", ENDITEM,
"Name=csrf", "Value={CsrfToken}", ENDITEM,
LAST);
lr_end_transaction("Sign-In", LR_AUTO);
return 0;
}What trips people up first
A script that replays green and tests nothing. The first replay of a recorded web script often reports success because every request returned 200, while the server actually answered with a login page or an error, since a session token or CSRF value was replayed from the recording. Compare the replay log with the recording, run Design Studio’s replay scan, and add a web_reg_find text check before each important request so a wrong page fails the step. The second hurdle is licensing: a scenario that mixes protocols, or uses a C Vuser template, may not start on the Community licence at all.
In practice
Using LoadRunner in practice
Keeping VuGen scripts in source control
A VuGen script is a folder: the .usr file that describes it, the action files (vuser_init.c, Action.c, vuser_end.c and any others), globals.h, the .prm parameter definitions with their data files, and default.cfg and default.usp for runtime settings and run logic. Commit all of those. Ignore the recording data folder, which the docs describe as a backup of recorded data that is never read again, replay result folders, and .bak copies. Keep one folder per business journey, Controller .lrs scenarios in their own folder, and environment details such as the base URL in parameters rather than in code. Enterprise Performance Engineering’s GitHub action can sync script folders to a project, uploading runtime files only by default.
# .gitignore for a repository of VuGen scripts
# Recording backup: written once, never read on replay
**/data/
# Replay results from VuGen
**/result1/
# Backup of the .usr file from before the last save
*.bak
# Controller and Analysis result folders, kept outside Git
results/Parameters and correlation that survive a release
Parameterise every value that differs between users or environments: user names, passwords, search terms and the base URL. Give each parameter a sensible selection rule, for example unique per Vuser for accounts that cannot log in twice. Correlate anything the server generates. Prefer boundaries that describe the value’s context, such as an attribute name, over long runs of HTML that a redesign will break, and set NotFound=error so a changed page fails loudly at the extraction rather than three steps later. When a page lists several values, capture them all with Ordinal=All and choose one, which spreads load across data the way real users do.
/* Capture every product ID on the page, then pick one at random */
web_reg_save_param_ex(
"ParamName=ProductId",
"LB=data-product-id=\"",
"RB=\"",
"Ordinal=All", /* creates ProductId_1, ProductId_2 ... and ProductId_count */
"NotFound=error",
SEARCH_FILTERS,
"Scope=Body",
LAST);
lr_start_transaction("Browse-Catalogue");
web_url("catalogue", "URL={BaseUrl}/catalogue", "Mode=HTML", LAST);
lr_end_transaction("Browse-Catalogue", LR_AUTO);
if (atoi(lr_eval_string("{ProductId_count}")) == 0) {
lr_error_message("No products listed for user %s", lr_eval_string("{Username}"));
lr_exit(LR_EXIT_ITERATION_AND_CONTINUE, LR_FAIL);
}
lr_save_string(lr_paramarr_random("ProductId"), "ChosenId");
web_url("product", "URL={BaseUrl}/product/{ChosenId}", "Mode=HTML", LAST);Designing scenarios in Controller
Start with a manual scenario: you choose the scripts, the Vusers for each, the load generators and the schedule, so the result is easy to reason about. Use goal-oriented scenarios when the question is a capacity target, such as how many Vusers keep a checkout transaction under two seconds. Set think time and pacing deliberately in the runtime settings, because a script that ignores think time turns 100 Vusers into far more traffic than 100 people. Keep the Controller machine out of load generation for anything beyond a smoke test, and watch load generator CPU and memory, since a saturated generator reports its own slowness as server latency. Define SLAs on the transactions that matter: the Jenkins integration only accepts scenarios that have them.
Running scenarios from Jenkins
The OpenText Application Automation Tools plugin, previously the Micro Focus plugin, runs Controller scenarios from Jenkins. Install the product on a Windows build agent, keep the .lrs files on that agent or in the checked-out workspace, and run the agent under an account with administrator rights rather than Local System. The loadRunnerTest pipeline step runs one or more scenarios, polls Controller, and publishes results; the SLAs in each scenario decide whether the build passes. Set perScenarioTimeOut so a hung scenario cannot hold the agent for hours, and keep pull request runs to a small smoke scenario. Azure DevOps has an equivalent extension, LoadRunner Professional Tests Automation, which needs a self-hosted Windows agent.
// Jenkinsfile: runs on a Windows agent with the product installed
pipeline {
agent { label 'lr-controller' }
stages {
stage('Load test') {
steps {
loadRunnerTest(
testPaths: 'scenarios\\checkout_peak.lrs',
archiveTestResultsMode: 'PUBLISH_HTML_REPORT',
controllerPollingInterval: '30', // seconds
perScenarioTimeOut: '90', // minutes
ignoreErrorStrings: ''
)
}
}
}
}GitHub Actions through Enterprise Performance Engineering
There is no official GitHub Action for the desktop Professional edition; a self-hosted Windows runner calling wlrun works, but wlrun documents no exit codes, so gating needs your own result parsing. The official route is Enterprise Performance Engineering’s action, MicroFocus/lre-gh-action, currently v1.0.7. It authenticates to the Enterprise server, runs an existing test by ID or creates one from a YAML file in the repository, waits for collation and analysis, writes reports to an LreResult folder and exits with a status suitable for gating. Store credentials as secrets, and set lre_status_by_sla to true so the SLA, not just a completed run, decides the job.
# .github/workflows/performance.yml
name: performance
on:
workflow_dispatch:
schedule:
- cron: '0 2 * * *'
jobs:
load-test:
runs-on: ubuntu-latest
permissions:
contents: read
env:
lre_username: ${{ secrets.LRE_USERNAME }}
lre_password: ${{ secrets.LRE_PASSWORD }}
steps:
- uses: actions/checkout@v7
- uses: actions/setup-java@v6
with:
distribution: temurin
java-version: '17'
- uses: actions/setup-node@v7
with:
node-version: '24'
- uses: MicroFocus/[email protected]
with:
lre_server: lre.example.com/?tenant=${{ secrets.LRE_TENANT }}
lre_authenticate_with_token: true
lre_domain: PERF
lre_project: checkout
lre_test: tests/checkout_peak.yaml
lre_post_run_action: Collate and Analyze
lre_status_by_sla: true
lre_output_dir: ${{ github.workspace }}
- uses: actions/upload-artifact@v7
if: always()
with:
name: lre-results
path: ${{ github.workspace }}/LreResultDevWeb when developers own the scripts
For HTTP and WebSocket services, DevWeb is the part of the family that suits a code review workflow. A script is a folder with main.js and rts.yml, so it diffs like any other JavaScript, runs from the command line on Windows, Linux or macOS, and scales later through Controller or Enterprise. Extraction uses load.BoundaryExtractor or other extractor objects on the request rather than separate registration calls, and transactions are objects you start and stop. Parameters come from load.params. Because Design Studio does not support DevWeb, correlation is written by hand, which is usually quicker for developers than reading recorded C.
// main.js: DevWeb script using the JavaScript SDK
load.action("Action", async function () {
const open = new load.Transaction("Open-Login");
open.start();
const page = new load.WebRequest({
url: "https://staging.example.com/login",
method: "GET",
// Extractors run on the response, like web_reg_save_param_ex
extractors: [new load.BoundaryExtractor("csrf", 'name="csrf" value="', '"')]
}).sendSync();
open.stop();
const signIn = new load.Transaction("Sign-In");
signIn.start();
const res = new load.WebRequest({
url: "https://staging.example.com/login",
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
// An object body is encoded to match the Content-Type
body: { username: load.params.username, password: load.params.password, csrf: page.extractors.csrf }
}).sendSync();
signIn.stop(res.status === 200 ? load.TransactionStatus.Passed : load.TransactionStatus.Failed);
});Pitfalls
Common pitfalls
Trusting a green replay
Why it happens: HTTP 200 is not success. An uncorrelated token or expired session often returns a login or error page with status 200, so VuGen and Controller record a pass while the server did none of the real work.
The fix: Add a web_reg_find text check before each important request, set NotFound=error on extractions, and compare the replay log with the recording snapshot until every dynamic value is correlated.
Discovering on test day that a protocol is not licensed
Why it happens: Licences are bundled by protocol and checked on the Controller at run time. A multi-protocol script needs every protocol licensed, and the free Community licence excludes the COM/DCOM, Templates and GUI bundles, so a hand-written C or Java Vuser will not run on it.
The fix: List the protocols in every script during planning, check them against the installed licences in the License Utility, and agree peak Vusers per bundle with whoever buys the licences.
Underscores in transaction names
Why it happens: Recorded and hand-written scripts often name transactions like 01_Login. The Analysis documentation warns that transaction names containing an underscore or an at sign cause errors when opening Cross Result graphs, which is exactly the view used to compare builds.
The fix: Agree a naming convention without _ or @, such as Login or Sign-In with hyphens, and apply it before a baseline exists, since renaming later breaks comparisons with old runs.
Following tutorials written for older product names
Why it happens: Most articles say LoadRunner Professional, LoadRunner Enterprise, LoadRunner Cloud and ALM, and describe a Jenkins step called Execute Micro Focus tests from file system. Under the current names these are Professional, Enterprise and Core Performance Engineering, Application Quality Management, and Execute OpenText tests from file system.
The fix: Map old names to new ones before searching the help centre, and use the version-specific help for your release. Scripts and scenarios are unaffected; only product, menu and plugin names changed.
Relying on removed components
Why it happens: Older guides set up the AutoPass License Server, TruClient Standalone or TruClient Lite. The deprecated features page lists the AutoPass License Server as no longer supported for running Vusers since 2023, TruClient Standalone as removed in 2023 and TruClient Lite as unsupported since 12.63.
The fix: Install licences on the Controller machine through the License Utility, and record and debug TruClient scripts inside VuGen. Check the deprecated features page before each upgrade.
Running load from the Controller or an overloaded generator
Why it happens: Controller collects data from every Vuser while running, and a load generator at full CPU or memory adds its own delay to every transaction. The result looks like server latency and leads to the wrong fix.
The fix: Keep Controller on its own machine for real tests, monitor every load generator during the run, and add generators before any of them approaches saturation. Validate a new generator with a small run first.
Compared
LoadRunner alternatives compared
| Tool | How tests are written | Licence | Protocol reach | Scaling past one machine | Results out of the box |
|---|---|---|---|---|---|
| LoadRunner | VuGen scripts in C; DevWeb in JavaScript | Commercial; free 50-Vuser Community licence | 180+ protocols, including SAP GUI and Citrix | Controller drives Windows and Linux load generators | Separate Analysis tool with SLAs and comparisons |
| Apache JMeter | GUI-built XML plans, Groovy for scripting | Apache 2.0, entirely free | JDBC, JMS, LDAP, FTP, TCP, mail built in | Built-in remote servers over RMI | HTML dashboard generated from results |
| k6 | JavaScript or TypeScript code | AGPL-3.0, paid Grafana Cloud k6 | HTTP, WebSockets, gRPC; more via extensions | k6 Operator on Kubernetes, or Grafana Cloud | Text summary, web dashboard, HTML export |
| Gatling | Java, Kotlin, Scala, JavaScript, TypeScript | Apache 2.0, paid Gatling Enterprise | HTTP, WebSocket, SSE, JMS in open source | Load generators in Gatling Enterprise | HTML report for every run |
FAQ
Frequently asked questions
What are the best LoadRunner alternatives?
The alternatives most often weighed against LoadRunner are Apache JMeter, k6 and Gatling. The comparison on this page sets them side by side on how tests are written, licence, protocol reach, scaling past one machine and results out of the box, and the verdict above says where LoadRunner is the wrong choice and which of them to pick instead.
Is LoadRunner free?
Partly. Every installation of Professional Performance Engineering, formerly LoadRunner Professional, includes a free Community licence for 50 Vusers on all protocols except the COM/DCOM, Templates and GUI bundles, intended for proof of concept and non-production testing. There is also a free trial with no credit card. Anything beyond 50 Vusers needs a paid licence, sold by Vusers within protocol bundles, and OpenText publishes no list prices.
What happened to LoadRunner? Was it renamed?
Yes. OpenText renamed the family to fit its wider portfolio, and explained the change in an October 2025 blog post. LoadRunner Professional is now OpenText Professional Performance Engineering, LoadRunner Enterprise is Enterprise Performance Engineering, LoadRunner Cloud is Core Performance Engineering, and LoadRunner Developer is Performance Engineering for Developers. OpenText says the tools, scripts, scenarios and processes are unchanged and backward compatible. VuGen, Controller and Analysis keep their names in the 26.x help, and the help centre still lives at admhelp.microfocus.com.
What is the current version of LoadRunner?
At the time of writing it is 26.3, covered by a combined 26.1 to 26.3 help centre. OpenText ships two releases a year. 26.3 extended Aviator, its AI assistant, in VuGen and Analysis, added an MCP server for the new Controller Service in private beta, a Blazor web protocol, CLS and INP graphs for TruClient 2.0, disk monitoring on Linux load generators and support for Windows 11 25H2.
Should I choose LoadRunner or JMeter?
Choose LoadRunner when the system under test uses protocols JMeter cannot drive in a supported way, such as SAP GUI, Citrix, Oracle Forms or terminal emulation, or when your organisation needs Enterprise’s shared projects, timeslots and trend reports. Choose JMeter for web, API, JDBC or JMS work, where it costs nothing and runs anywhere Java runs. LoadRunner can also run JMeter scripts, so a mixed estate does not have to rewrite them.
Can LoadRunner run in CI/CD?
Yes, with some setup. For Professional, the OpenText Application Automation Tools plugin runs Controller scenarios from Jenkins, and an Azure DevOps extension does the same; both need a Windows agent with the product installed, and Jenkins needs SLAs in the scenario to decide pass or fail. For GitHub Actions, the official action, MicroFocus/lre-gh-action, targets Enterprise Performance Engineering. Core Performance Engineering runs tests from its cloud service.
What language are LoadRunner scripts written in?
It depends on the protocol. Web HTTP/HTML scripts recorded in VuGen are C by default, using functions such as web_url, web_submit_data and lr_start_transaction. DevWeb scripts are JavaScript. TruClient scripts are recorded steps with JavaScript or C for custom logic. The Templates bundle covers hand-written C, C++ .NET, C# .NET, Java and VB .NET Vusers, and JMeter and Gatling scripts can also run as Vusers.
Does LoadRunner run on Linux or macOS?
Only in part. VuGen, Controller and Analysis are Windows applications, and the Azure DevOps integration needs a Windows agent. Load generators can run on Windows, Linux or Docker, controlled by the Windows Controller. DevWeb scripts can be written and run on Windows, Linux and macOS through Performance Engineering for Developers, and Core Performance Engineering is a web service you reach from any browser.
Is LoadRunner still worth learning in 2026?
Yes, if you work in enterprises with SAP, Citrix, Oracle or mainframe systems, or in organisations that standardised on it years ago, because those estates rely on VuGen skills, correlation experience and Analysis. If you work mainly on web services and APIs, learn k6, JMeter or Gatling first; the workload modelling, correlation and analysis habits transfer to LoadRunner if you meet it later.
Alternatives
LoadRunner alternatives worth weighing
Apache JMeter
Apache-licensed Java load testing tool: test plans are built in a desktop GUI and run from the command line, covering HTTP, JDBC, JMS, LDAP, FTP, TCP and more.
k6
Open source load testing from Grafana Labs: a Go engine runs JavaScript or TypeScript scripts, with thresholds that fail CI runs and an optional paid cloud service.
Gatling
Load testing as code on a non-blocking Netty engine, with simulations written in Java, Kotlin, Scala, JavaScript or TypeScript and an HTML report per run.
Resources
Where to go next
Keep going
Prepare, or get it done
Picking the wrong tool costs more than picking late.
QAble advises on toolchain decisions and then implements them, with engineers who have run these tools on real delivery. Start with a free QA audit.