RobotCode | News

What's New in v2.8.0

Sun, 25 Oct 2026 00:00:00 GMT

RobotCode v2.8.0 is a big release. It supports Robot Framework 7.5 and is the biggest update yet for PyCharm, where RobotCode now offers nearly everything it offers in VS Code, from run configurations and debugging to test results and settings. VS Code gets a Documentation Viewer and follows your Python environment by itself, and the website has moved to a new platform with a new structure, a polished design and new guides, along with much more.

Not everything is perfect yet, and there is still quite a bit of work ahead, but we are working on it. I look forward to feedback, reviews and suggestions for improvement from the community.

Highlights

Robot Framework 7.5 support: See the argument descriptions that libraries document while you type, and run, list or inspect only the tests with certain metadata.
Documentation Viewer: Read the documentation of any library or resource file in a VS Code editor tab, right next to your code, one click away from a hover, and bookmark what you look up often.
PyCharm: The plugin's biggest update yet brings nearly everything the VS Code extension offers: run and debug your tests with run configurations and robot.toml profiles, see in the results where a test failed, use breakpoints with conditions and hit counts and the new Robot Debug Console, and set almost everything you can set in VS Code.
Python environments in VS Code: RobotCode uses the environment of the new Python Environments extension and picks up another environment or a fresh Robot Framework installation by itself, without restarting VS Code.
A new website: robotcode.io has moved to Astro with Starlight, is reorganized, has a polished design and new guides for VS Code, PyCharm and robot.toml.

Breaking Changes

The VS Code extension needs VS Code 1.127 or newer. Older VS Code versions keep the newest RobotCode release they can install.
The PyCharm plugin needs PyCharm or IntelliJ IDEA 2026.1 or newer. Older IDE versions no longer receive plugin updates.
--tags is now --show-tags. In robotcode discover and robotcode results show, the switch that prints the tags of each test is renamed to --show-tags / --no-show-tags, to match the new --show-metadata. The old name is no longer accepted, so update any scripts that use it.
A profile name that selects no profile now stops the command. If a name or pattern from -p, ROBOTCODE_PROFILES, the editor's selection or inherits matches no profile, the command ends with exit code 252 before anything runs, instead of running with a different configuration. "No profile matches" explains what to do.

Robot Framework 7.5 Support

RobotCode now supports Robot Framework 7.5 and brings its new features into your editor and onto the command line. What is new in Robot Framework 7.5 itself is described in the Robot Framework documentation; here is what you get in RobotCode.

Richer Keyword Documentation

With Robot Framework 7.5, keywords can describe their arguments, return values and exceptions in Google style, with Args:, Returns: and Raises: sections. RobotCode shows these descriptions where you need them. The hover of a keyword lists its arguments with their descriptions, followed by the return value and the exceptions:

While you type the arguments of a keyword call, the signature help now also shows the description of the argument at the cursor, right below the signature:

Libraries can now also write their documentation in Markdown, as the standard libraries do, and RobotCode renders it.

Test and Task Metadata

Robot Framework 7.5 lets tests and tasks carry their own [Metadata]:

*** Test Cases ***
Login Works
    [Metadata]    Issue    4409
    Open Login Page

RobotCode shows this metadata in the hover of a test and offers the new ${TEST_METADATA} variable in completion.

You can also run, list and inspect only the tests with certain metadata. -btm/--by-test-metadata and -ebtm/--exclude-by-test-metadata take patterns like tag patterns and work with robotcode robot, discover and results. robotcode discover metadata lists the metadata in use.

robotcode robot -i smoke -btm Issue:4409   # run the smoke tests for issue 4409
robotcode discover metadata --values       # the metadata names and values in use

With the pre-run modifiers of the robotcode-modifiers package, the selection also works with plain robot and in robot.toml profiles. Selecting by test metadata describes the patterns and how to use them.

Also on Robot Framework 7.5

Markdown files: Resource imports accept Markdown files (.md, .markdown, .robot.md). RobotCode also finds the tests in .robot.md files, but Robot Framework 7.5 reports their line numbers relative to the code blocks instead of the file, so their run buttons appear at the wrong lines. The bug is reported (robotframework#5801) and its fix is planned for Robot Framework 7.5.1; once that release includes it, the buttons will appear in the right place.
robot.toml: console takes a custom console class or module, the libdoc formats accept MARKDOWN, and the [rebot] section takes the new console and quiet options.
Deprecation: A Tags: section in keyword documentation without an empty row before it gets a warning, as Robot Framework 7.5 deprecates the missing empty row.

VS Code

Documentation Viewer

The VS Code extension has a new Documentation Viewer. It shows the documentation of any library, resource file or suite file in an editor tab, and it matches your project, because it is generated with the installed library versions and your project's settings. You open it with:

A click on a link in a hover.
Show in Documentation Viewer in the Source Action… menu of a Library or Resource import, a keyword call or a keyword definition.
The book button in the Keywords view.
RobotCode: New Documentation Viewer in the command palette or the button at the end of a viewer's toolbar, for any library or file.

You can open several viewers at the same time, each with its own library or file, and arrange them like any other editor: side by side, in other editor groups or in a window of their own. Show in New Documentation Viewer, offered next to Show in Documentation Viewer, opens another one, and the pin in a viewer's toolbar decides which viewer the next action uses.

Bookmarks take you back to the documentation you look up often. The star after the target field bookmarks the place a viewer shows, such as a library or a keyword in it, and the new Documentation Bookmarks view in the Explorer lists your bookmarks: a click shows one in the viewer, and buttons in its title bring the viewer to the front or open a new one. A bookmark holds for its workspace folder until you move it to All Workspaces, where it holds in all your workspaces and reaches your other machines with Settings Sync. On its first start, RobotCode bookmarks the standard libraries in All Workspaces.

While you type a target, the field offers your bookmarks and completes the names of libraries, resource files and suite files, and the context menu of the outline opens the file that defines a keyword, also the Python file of a library such as Collections.py. Documentation Viewer in the VS Code guide has the details.

Open Documentation, which shows Robot Framework's Libdoc HTML, is now marked as deprecated in favor of the viewer, as is Show Documentation in the context menu of the Keywords view. Both keep working.

The Python Environment

RobotCode now works with the new Python Environments extension and uses the environment it selects for a folder. Select another environment or install Robot Framework, and RobotCode picks up the change by itself: it restarts the language server, without a restart of VS Code. If something is missing, a message tells you what, instead of a dialog that waits for an answer. The Python environment has the details.

Test Runs in RobotCode's Own Terminal

Tests now run in a terminal of RobotCode's own, whether you start them from the Test Explorer, the editor or a launch configuration. Robot Framework runs there without a shell, so every run gets the same environment, the interpreter of its workspace folder, and no activation command of the Python extensions lands in the middle of a run. Before each run, the terminal shows the run's command line as you would type it, with its profiles and options; VS Code's command decoration copies the command or the output, and the terminal is reused for the next run. The output of a run has the details. Set robotcode.debug.defaultConsole to integratedTerminal to run in a shell of VS Code's integrated terminal as before.

See Where a Test Failed

A failed test now shows each of its failures in the editor, at the step of the test that led to it. A click on its marker opens a peek below the step with the whole message and the calls from the step to the line that failed, each with a few lines of its code, so you see at once where the test went wrong. Failures that the test caught, for example with TRY/EXCEPT, are listed too, marked as caught.

When a debug run stops at a failure, the editor shows the failed keyword and its message below the line and lists the same calls, with links to their lines. Running and debugging in the Test Explorer guide and Stopping at failures have the details.

Also in VS Code

The language server starts as soon as you open a folder with Robot Framework files, not only when you open one of them.
When VS Code restores an open Robot Framework file at startup, the Keywords view shows its keywords as soon as the language server runs, and canceled requests of the view no longer show up as errors in the output. (#644)
The Test Explorer follows every change of suite files and folders, also changes made outside VS Code, for example by git or in a terminal, keeps its results in projects with several paths in robot.toml, and Run Tests runs every workspace folder. Where the tests come from describes when it updates.
An empty Test Explorer says why and offers what helps: without a Python environment with Robot Framework, for example, it offers Select Python Environment; see Problems while finding the tests. A failed discovery no longer leaves the suites of the last discovery next to its error.
The language status marks only the item with the problem: when the environment has no Robot Framework, only the Robot Framework item shows an error, not the Python item.
RobotCode: Copy Environment Info, also in the RobotCode menu of the language status, copies the versions of VS Code, RobotCode, the operating system, Python, Robot Framework and Robocop for an issue, a forum post or a chat. (#260)
RobotCode: Start Terminal REPL runs the REPL with the folder's Python environment, not with the first robotcode on the PATH.
Code blocks marked robotframework or robot in Markdown get Robot Framework colors in the Markdown preview and in the Documentation Viewer.
Breakpoints with a hit count stop at that hit, and hit counts such as >= 3 or % 2 work; Debugging lists the forms.
After Stop, a breakpoint in a teardown no longer pauses the run again.
The robotcode command in VS Code's terminals also works on systems without bash and when the extension's path contains a space, for example from a Windows user name.

PyCharm

For PyCharm and IntelliJ IDEA, this release is the biggest step since the plugin's first version. Up to v2.7.0, the plugin brought the language features of RobotCode, such as completion, hover, diagnostics and navigation, while running, debugging and the settings offered much less than in VS Code. Now it offers nearly everything the VS Code extension does: you configure RobotCode on settings pages with the names you know from VS Code, run and debug your tests with run configurations and profiles, and see right in the results where a test failed. That makes it one of the most complete Robot Framework plugins for PyCharm. A few things are still missing, such as the Test Explorer and the Documentation Viewer, and we are working on them; RobotCode in PyCharm and VS Code compares both, and the new PyCharm guide shows how to work with the plugin.

Run configurations as in VS Code. Robot Framework run configurations now keep what they run, files and folders or tests and suites, across restarts, can be stored with the project and are edited in the IDE's run configuration editor, with the interpreter, environment variables, the Robot Framework options and the run and debug options of VS Code's launch configurations, such as a launch wrapper like xvfb-run. A run configuration can use the robot.toml profiles selected for the project or its own, and Run with Profile… in the gutter runs a test or suite once with another profile. Runs from the gutter reuse their configuration instead of creating copies, and the editor of a run configuration shows when its interpreter lacks Robot Framework, a target path is missing or a selected test is gone. (#418)
Run tests from every context. Ctrl+Shift+F10 (Ctrl+Shift+R on macOS) runs the test at the cursor or the suite of the file, several selected files or folders run together, and suites in the results tree can be run again. With Robot Framework 6.1 and newer, a run of a single test or suite parses only the files it needs, and the tasks of RPA suites get run markers too. (#631)
Test results that show where a test failed. A failed test lists each of its failures with the calls that led to it, from the call in the test inward, with links to their lines, and a double-click opens the call in the test that led to the first failure. Selecting a test shows the log messages it wrote, and the output of the run has a Terminal tab of its own. Rerun Failed Tests runs exactly the tests that failed, and report and log open in a preview tab whose toolbar switches between them. (#528)
Almost everything you can set in VS Code, you can now set here too. Settings pages under Languages & Frameworks › Robot Framework cover Robot Framework options such as the Python path and variables, editing and completion, analysis and diagnostics, Robocop, running and debugging, the language server and the command line, with the names VS Code uses. You can select the configuration profiles of your robot.toml and switch RobotCode off for a project, and the status bar shows the Robot Framework version and the selected profiles. The analysis cache no longer lands in the project folder, where the IDE indexed it.
Content and source roots are on the Python path. The analysis, test discovery and runs find libraries and resource files in the project's content roots and in folders marked as Sources or Test Sources, as PyCharm's Python run configurations do; two switches on the Robot settings page turn this off. (#430)
Completion in robot.toml. PyCharm completes the settings of robot.toml and .robot.toml from RobotCode's schema, without a schema mapping by hand, and Markdown code blocks marked robot are highlighted as Robot Framework code, like those marked robotframework.
Breakpoints with conditions, log messages and hit counts. Line breakpoints get a condition, a log message and a hit count, and the IDE applies their suspend policy and options such as Remove once hit. Changes to breakpoints take effect at once in a running debug session, Run to Cursor always reaches its line, and the Any Exception breakpoint, which never reached the debugger, is replaced by Robot Framework exception breakpoints for failed keywords, tests and suites.
A Robot Debug Console and values on hover. While a run is paused, the new Robot Debug Console, Evaluate Expression and watches complete the keywords and variables of the paused run, hovering a variable shows its value, lists expand into their items, and Set Value changes variables. Watches work as in VS Code, and running, stepping and evaluating no longer freeze the IDE. Stop ends a run gracefully, also while it is paused, so the run still writes its output, log and report.
Colors come from the active color scheme. Variables, keyword calls, operators and numbers get colors from your scheme instead of plain text, and the plugin no longer ships its own colors for Darcula, Dark and Light. Colors you set on the Robot Framework color settings page are kept, and type hints and parameters have color settings of their own. (#655)
Test case and keyword names are highlighted right away. Their colors no longer wait for the language server.
Show Usages finds more and names what it searches for. In Robot Framework files, Show Usages and Find Usages search for the name at the cursor, as VS Code does, and name its kind and name, such as "Keyword Open Shop As", instead of "LSP Usage Triggered Psi Element". They find the usages of a keyword called with a library prefix, such as BuiltIn.Log, and on a resource import they list where the file is imported and where its keywords are called with its name in front. LSP Reference(s) now also works on library keywords and on variables from Python variable files.
The Python environment is checked in the background. The check no longer blocks the editor and says what is wrong, such as an old Python or Robot Framework version or a missing Robot Framework; a banner offers to choose another interpreter, to check again or to switch RobotCode off for the project. RobotCode starts only in projects with Robot Framework files or a robot.toml.
A sturdier language server. Its output no longer shows up as IDE errors, a start that fails ends with a message instead of hanging, and the IDE no longer freezes when Robot Framework files are deleted, created or renamed. It restarts only when its settings change, and Restart picks up an interpreter you fixed outside the IDE.
Updates ask for a restart and say what's new. Installing or updating the plugin asks for a restart of the IDE instead of leaving it without RobotCode's features, and after an update a notification offers What's New?, which opens these news, as in VS Code.
Your own templates for .resource files appear in the New Robot Framework File dialog. Thanks to Pāvels Koržs.

Language Server and Analysis

More Robust Library Loading

A library that hangs or exits while it loads no longer holds up the editor or robotcode analyze code: RobotCode stops it after the load timeout and shows the problem at the import. Changed arguments of a library import now take effect right away, and if a library can't be set up with the given arguments, the import tells you so.

Cleaner Keyword Completion

Keyword completion no longer offers keywords tagged robot:private from other files; the setting robotcode.completion.hidePrivateKeywords brings them back. Calls of private library keywords are now reported too, and the new setting robotcode.completion.hideDeprecatedKeywords leaves deprecated keywords out of the list. (#495, #652)

Also in the language server and analysis

Find References, Rename and the unused hints keep up with the files on disk, also with files created, changed or deleted outside the editor and with all files that import a changed resource file; a check every five minutes, set by robotcode.analysis.fileCheckInterval, finds the changes the editor doesn't report.
Find References also works on the library or resource name in front of a keyword call, such as BuiltIn in BuiltIn.Log, and lists EXCEPT AS and item assignments such as ${items}[0]= with the variable they set, so Rename renames them too.
The language server now also starts when robot.toml can't be loaded or a profile name selects no profile, and reports the problem as an error message instead of only in its log. VS Code and PyCharm report a selected profile that robot.toml doesn't define and offer to remove it from the selection.
A library import that Robot Framework 7.4 and newer ignores, because an earlier import already uses its name, is now reported.
A file that you edited, saved and closed is no longer analyzed with the text from before your edit.
After a change of the Python path or of an environment variable, files whose imports or variables it affects are analyzed again instead of keeping their old diagnostics, also closed ones.
After the languages setting changed, files from the analysis cache are read again, so a resource file with section headers in another language no longer stays empty.
# robotcode: comments that change diagnostics work as documented: warning[…] and information[…] change only the listed codes, a comment after a nested block takes effect, and the nearest comment wins.

AI Agents

RobotCode comes with a chat plugin for AI agents: the VS Code extension ships it for GitHub Copilot Chat, switched on by default, and Claude Code, Codex, GitHub Copilot CLI and other agents install the same plugin from its marketplace. Its skill tells the agent how to use robotcode on your project and is up to date with this release: the agent now looks up keywords and libraries with robotcode doc, so it sees the keywords of the libraries you actually have installed, and it knows the other new commands and options, such as the selection by test metadata and the exit codes of the REPL.

The plugin now carries the version of the RobotCode release it belongs to. The copy in the VS Code extension always matches the extension, and every release is now tagged in the marketplace, so other agents can pin the plugin to the version of RobotCode that a project uses. Working with AI Agents shows how to set it up and how to pin it.

The language model tools of the VS Code extension are now deprecated: the chat plugin replaces them, and VS Code marks the setting robotcode.ai.enableLanguageModelTools as deprecated. The tools keep working until a later release removes them.

Command Line and REPL

`robotcode doc`

The Documentation Viewer is built on the new robotcode doc command, which you can also use on its own in the terminal. It shows the documentation of a library, resource file or suite file the way your project sees it, with the installed library versions and your robot.toml profiles.

robotcode doc keywords Collections dictionary   # the keywords of Collections that match "dictionary"

robotcode doc comes with the optional repl package (pip install "robotcode[repl]"); Browsing Library Documentation has the details.

A More Dependable REPL

A statement that fails without being handled now fails the REPL session, and a non-interactive session exits with 1, so scripts, CI and agents can tell success from failure. You can also choose the exit code yourself; see the REPL reference. Several fixes make robotcode repl and the notebook kernel more reliable: .save leaves out inputs that failed, so the saved file runs, and settings such as [Tags] typed at the prompt are reported instead of silently ignored. (#663, #667)

Ctrl-C now works as in Python's REPL and in pdb: at the prompts of repl and robot-debug it drops what you typed instead of ending the session or resuming the run, and while a run executes under the debugger it pauses at the next keyword.

Also on the command line

On Windows, robotcode commands no longer fail when a given path is on another drive than the working directory.
robotcode discover no longer fails when a custom parser or a pre-run modifier creates a test without a line number, so VS Code and PyCharm show the tests of such a project too.
robotcode results log --extract finds screenshots whose names are URL-encoded, follows the file: links of the OperatingSystem library and extracts the videos the Browser library records.
Keyword breakpoints of robot-debug and .break match names like Robot Framework, also with glob patterns such as BuiltIn.*.
robotcode analyze code keeps its cache in the cache-dir set in robot.toml, and discover files takes relative paths from the folder it is started in.
In robot.toml, an extend- setting such as extend-variables now adds to its setting also when both are in the same profile or file, and in [extend-profiles.<name>].
In robot.toml, a setting in [rebot], [libdoc] or [testdoc] now wins over the same setting outside the table, and [extend-rebot], [extend-libdoc] and [extend-testdoc] change these tables from a later file or a profile.
In robot.toml, selecting a disabled profile no longer applies the profiles two or more levels up its inheritance chain.
repl, repl-server and robot-debug end on SIGTERM, as sent by kill or a process manager, also while they wait for input.
Colored output of discover and results paged through bat no longer shows an empty line after each line.

A New Website

robotcode.io has moved from VitePress to Astro with Starlight. Its pages were carried over, the design is polished, and the documentation is reorganized by what you come to do: Getting Started helps you install and configure RobotCode, Guides show how to work with it, and Reference lists the commands, the robot.toml and VS Code settings and the diagnostics modifiers. New guides to VS Code and PyCharm show how to write, navigate, run, debug and configure Robot Framework projects there, and Configuring Projects with robot.toml explains what robot.toml can do. The new home page shows RobotCode at work in short demos: editing in VS Code, PyCharm and Neovim, running and debugging tests, the configuration, the command line and the REPL, and an AI agent that writes, finds and fixes tests with the RobotCode skill. The news section has tags and an RSS feed, and after an update the What's New notification of the VS Code extension opens the newest release notes.

The reason for the move: VitePress 1 gets no further releases, and VitePress 2 has been in alpha since January 2025, without a guide for moving from version 1. VitePress 1 also depends on old versions of Vite and esbuild with known security vulnerabilities, one of them rated high, which get no fix on the 1.x line. They affected only the tools that build the site, not the published pages. Starlight, in contrast, is actively developed.

All pages have new addresses, and the old addresses are not redirected, so update your bookmarks.

Python 3.15

RobotCode now also runs on Python 3.15, which Robot Framework supports from version 7.5. The CI no longer tests every Robot Framework version with every Python version, only with the Python versions that Robot Framework itself officially supports, because there would be too many combinations otherwise. This changes only what the CI tests, not which combinations RobotCode runs with.

Nightly Builds

Every night, the newest build of main is published as a pre-release, so you can try new features and fixes before the next release. In VS Code, choose Switch to Pre-Release Version on the page of the RobotCode extension. In PyCharm, add https://plugins.jetbrains.com/plugins/dev/26216 as a custom plugin repository. The Python packages are on PyPI as dev versions such as 2.8.0.dev527: pip install robotcode keeps installing the latest release, and a dev version is installed only when you pin it. Try the Dev Builds shows how to switch to them and how to go back to a release.

Bug Fixes

In VS Code, a run from the Test Explorer now ends as Robot Framework ends it: it keeps Robot Framework's exit code, and the Browser library closes its Playwright process and its browsers at the end. (#635)
An environment variable with an empty default, such as %{NAME=}, is no longer reported as not found when NAME is not set. (#653)
In VS Code, the exception breakpoint for failed tests stops again, and keywords you run at such a stop work, also at a failed-test stop of robot-debug. The exception breakpoints are now called Failed Tests and Failed Suites; if you had switched one of them on, switch it on again once after the update. (#664)
A breakpoint condition that raises an error now shows the error, in VS Code's Debug Console and in robot-debug, instead of counting as true or false. (#669)
In JetBrains IDEs, breakpoints in files of other languages, such as C# in Rider, are no longer turned into Robot Framework breakpoints. (#658)
In a PyCharm project with several modules, RobotCode uses the interpreter and the roots of the module that holds the Robot Framework project, not the first module with an interpreter, and asks when several modules qualify; the General settings page can change the module. (#489)
In PyCharm, Go to Declaration on a variable jumps to its definition again. (#660)
In PyCharm, Go to Declaration on a keyword called with a library or resource prefix lands on the keyword every time, not only the first time. (#464)
Closing a project or quitting PyCharm while the language server is still starting no longer reports an error. (#630)
In PyCharm, tests whose suite teardown fails show as failed, and the run console keeps the output in the order Robot Framework wrote it. (#458)
--dry no longer starts the wrapper configured in robot.toml, and debug and repl-server no longer hang with --dry. (#665)
Commands that run Robot Framework exit with 252 when RobotCode itself reports an error, such as an invalid robot.toml or a wrapper that doesn't start, so a CI job can tell a broken setup from failed tests. (#666)
The help of the REPL's .set and the command-line debugging guide now say that .set only changes existing variables and always stores a string. (#670)
The configuration guide now names the correct location of the global user configuration: a robot.toml in the platform's user configuration directory (for example ~/.config/robotcode/robot.toml on Linux), not ~/.robot.toml. (#637)

Under the Hood

The experimental SemanticModel introduced in v2.6.0 has made good progress: with semantic-model = true, semantic highlighting, selection ranges and the debugger's inline values now run on the model and behave as without it. It is still off by default; the v2.6.0 post shows how to try it.

Thank You

Thanks to everyone who reported issues, contributed ideas and code, and tested pre-release builds. Your feedback drives every release.

If you like RobotCode, please help others find it: we need more reviews in the VS Code Marketplace and the JetBrains Marketplace, and more stars on GitHub. Donations through GitHub Sponsors or Open Collective are very welcome too and help keep the project sustainable.

For the full list of changes, see the Changelog.

What's New in v2.7.0

Wed, 15 Jul 2026 00:00:00 GMT

RobotCode v2.7.0 is about running tests in the environment they actually need. The new wrapper option lets a command of your choosing bring up that environment — services, mocks, a graphical session — run the tests inside it, and tear it down again, from the command line and from your editor alike. Alongside it, the analysis cache is now trustworthy under rapid file changes, so stale errors no longer stick around in the editor or the CLI. And running a subset of tests from the VS Code Test Explorer works cleanly again on Robot Framework 6.1+.

Run Tests Through a Wrapper

Some test runs need more than the tests themselves: a database, a mock server, a docker compose stack, or a virtual display for UI tests. The new wrapper option tells RobotCode to run its actual command through a command of your choosing — the wrapper prepares the environment, runs the appended robotcode command in it, and cleans up afterwards.

Configure it per profile in robot.toml:

# A ready-made tool — here a virtual X server for headless UI tests
[profiles.headless]
wrapper = ["xvfb-run", "-a"]

# Your own script — bring the test environment up, then tear it down again
[profiles.integration]
wrapper = ["./with-test-services.sh"]

Or set it ad hoc for a single run:

robotcode --wrapper "xvfb-run -a" run tests/
robotcode -p integration --no-wrapper run tests/   # ignore the profile's wrapper

The wrapper applies to every command that executes Robot Framework — run, robot, debug, repl, run-debug and repl-server — and never to commands that don't run tests, like the language server, discover, or libdoc. It can also be set through the ROBOTCODE_WRAPPER environment variable.

Editors pick it up automatically, because they run robotcode for you: a wrapper in your selected profile already wraps the tests you run or debug from the VS Code Test Explorer. If you want an editor-only override without touching robot.toml, set robotcode.debug.launchWrapper — it takes precedence over the profile's wrapper and has no effect on the command line.

If your run only needs environment variables, you still don't need a wrapper — keep using [env] in robot.toml. Reach for a wrapper when something has to run around the tests.

The wrapper works on Linux, macOS, and Windows — on POSIX systems RobotCode replaces itself with the wrapper command, on Windows it spawns it and forwards the exit code, and the contract for your script is the same everywhere. The new Running Tests Through a Wrapper reference explains the details and includes complete, copy-ready Bash and PowerShell wrapper scripts.

A Trustworthy Analysis Cache

Fast consecutive changes to several files could previously poison the analysis cache: the editor and the CLI then reported errors that did not exist — missing keywords, unresolvable variables — until the affected files were touched again.

In v2.7.0, cached analysis results are bound to exactly the file state they were computed from, and unsaved editor content is analyzed but never cached. Stale results can no longer stick, so what the editor and robotcode analyze code report reflects your files as they actually are — even while you are editing quickly across resource files, branches, or generated code.

Bug Fixes

Running a subset of tests from the Test Explorer works again on Robot Framework 6.1+. Since 2.6.0, running a single test, a file, or any subset from the VS Code Test Explorer no longer passed Robot Framework's parse-include (-I) and top-level suite name (-N) options, so the run parsed the whole workspace and surfaced parse errors from unrelated files. Both options are passed again. For scripts and agents consuming robotcode discover -f json: Robot Framework's --parseinclude support is now reported once as a supportsParseInclude key on the result, replacing the previous per-item needsParseInclude key. (#624)

There is also a small fix for JSON output: the compact JSON mode now actually emits compact separators instead of the pretty-printed spacing.

Thank You

Thanks to everyone who reported issues, contributed ideas, and tested pre-release builds. Your feedback drives every release.

For the full list of changes, see the Changelog.

What's New in v2.6.2

Mon, 15 Jun 2026 00:00:00 GMT

Two patch releases landed today on top of v2.6.0 — v2.6.1 and v2.6.2 — all bug fixes from your reports. Thanks for filing them.

v2.6.2

The Test Explorer recovers after a language server restart. After restarting the language servers — for example via Clear Cache and Restart Language Servers — test items and the run/debug buttons no longer disappear until you reload the window. RobotCode now re-discovers each folder's tests and rebuilds its run profiles automatically when its language server comes back, and each workspace folder refreshes on its own without interfering with the others. (#618)
More reliable test runs. A run no longer hangs with a spinning indicator when a debug session fails to start, cancelling a run now stops only that run (and works even while it is still starting), and a test's error decoration clears as soon as the underlying problem is fixed. (#618)

v2.6.1

Automatic recovery from a corrupt cache database. When the workspace cache became corrupt (database disk image is malformed), the keyword view, test discovery, and even Clear Cache and Restart Language Servers stopped working. RobotCode now detects the corruption and rebuilds the cache automatically — or falls back to an in-memory cache if the file is still locked by another window. (#614)
Stale configuration profiles no longer block test runs. If a selected profile was removed from robot.toml — for example after switching git branches — every test run failed with a profile not found error. Select Configuration Profiles now drops profiles that no longer exist and lists which ones were removed. (#498)
Stable Robocop formatting. Formatting a file with Robocop repeatedly no longer flips between two results — for example a blank line being added and removed before a section header on every other run. (#612)
pip install robotcode[all] works on more platforms. On targets without a prebuilt html-to-markdown wheel (such as armv7l or Alpine/musllinux), the install used to fail during a source build. html-to-markdown is now opt-in instead of part of all — install it with pip install robotcode-runner[html] for nicer HTML log conversion in the results command. (#613)

There is also a new reference page on excluding files with .robotignore.

Thank You

Thanks to everyone who reported issues, contributed ideas, and tested pre-release builds. Your feedback drives every release.

For the full list of changes, see the Changelog.

What's New in v2.6.0

Tue, 09 Jun 2026 00:00:00 GMT

RobotCode v2.6.0 builds out a Robot Framework project's command line — new commands alongside sharper versions of the ones you already use — so working with a project means asking focused, structured questions instead of wading through raw .robot and .resource files, output.xml, or log.html. These project-aware commands discover tests, inspect finished runs, check code, explore keyword documentation, and debug a run. The work was driven by what AI agents need to operate a project without guessing, and a first version of chat plugins lets an agent drive the robotcode CLI directly — honoring your robot.toml, profiles, and Python environment, with more to come. It turns out a clean command line is exactly what developers and CI pipelines wanted too: readable Markdown at the prompt, and machine-readable JSON, SARIF, or GitHub and GitLab reports for pipelines. Separately, this release introduces the first experimental SemanticModel preview, a new foundation for deeper, more consistent Robot Framework analysis across RobotCode. A documentation refresh ties it together, explaining these workflows so agents and humans share the same resolved view of a project.

Inspect Robot Framework Runs from the Terminal

The new robotcode results command group lets you inspect finished Robot Framework runs straight from the terminal — the answers you'd normally hunt for in report.html or log.html, delivered as plain text instead. It is designed for quick local triage, CI logs, shell scripts, and AI-driven failure analysis, where compact summaries and structured output matter more than handing a whole result file to a chat session.

The command group covers the common result questions: summary gives a compact overview, show lists matching tests, log prints the execution tree, stats aggregates larger runs, and diff compares two result files. The active robot.toml profile is used to find the output file automatically, while -o/--output can point to a specific one.

Results can be filtered by status, tags, suites, tests, and long names, and --failed, --passed, and --skipped are available as quick additive shortcuts for common status filters. --search / --search-regex can narrow large runs by names, failures, keyword calls, arguments, log messages, and metadata.

Human text output is now Markdown. In an interactive colored terminal, RobotCode renders that Markdown with themed tables, headings, lists, status markers, highlighted matches, and terminal-friendly links. In a pipe, redirected output, or --no-color session, the raw Markdown is emitted as-is, which makes it useful for CI logs, pull requests, chat tools, and AI-agent workflows. --format json remains the stable payload for scripts, CI, editor integrations, and agents.

For deeper inspection, results log can include keyword or suite information with --keyword-info and --suite-info, and it can extract embedded artifacts such as screenshots into a directory.

robotcode results summary
robotcode results show --failed --search login
robotcode results log --failed --keyword-info

For the full guide and more recipes, see Analyzing Run Results.

Searchable Project Discovery

Human discover output now follows the same Markdown-first approach as results: project trees, file lists, suite lists, test lists, task lists, tag summaries, and statistics render nicely in terminals while staying pasteable as plain Markdown when output is captured. JSON output is unchanged and records the applied search filter for scripts and agents.

robotcode discover also gains --search and --search-regex across all, files, suites, tags, tasks, and tests. That makes it easier for humans and agents to answer project-inventory questions without dumping the whole tree first: search can match names, long names, source paths, documentation, templates, timeouts, tags, suite documentation or metadata, and test body content such as keyword calls, arguments, assignments, control-flow conditions, and setup or teardown steps.

Parsing errors and warnings no longer clutter the default output. When a suite has parse issues, discover now prints a compact Diagnostics summary with the error and warning counts after the statistics, and --diagnostics lists the full messages on demand. JSON output still carries the complete diagnostics, so editors and agents are unaffected.

For the full discovery guide, including JSON output shapes and CI recipes, see Discovering Tests, Tasks and Suites.

CI-Ready Static Analysis Output

robotcode analyze code is now easier to use locally, in CI, and as an agent preflight check before running a suite. The default concise output prints diagnostics in source order, uses full severity names such as [ERROR] and [WARNING], and formats multi-line messages and related locations more clearly. Robot Framework tracebacks and long PYTHONPATH dumps are hidden by default so routine CLI output stays focused; use --show-tracebacks when you need the full diagnostic body.

For automation, the command now has structured output formats for JSON, SARIF, GitHub Actions annotations, and GitLab Code Quality reports. --output-file writes machine-readable reports directly to disk, and --full-paths switches between project-relative and absolute paths. The new --severity and --code filters let you narrow the reported diagnostics without remapping their severities, so the output, summary, and exit code stay aligned.

robotcode analyze code
robotcode analyze code --severity error,warning
robotcode analyze code --output-format sarif --output-file robotcode.sarif

Path filtering is also stricter: passing a path such as tests/api no longer accidentally includes sibling folders like tests/api_v2. Workspace-level diagnostics now get an explicit .: source marker instead of appearing without any location context. Unused keyword and variable diagnostics now go through the same diagnostic modifiers as every other diagnostic, so -mi, -mX, and inline # robotcode: comments apply consistently.

For the full guide, including SARIF and CI recipes, see Analyzing Code.

A Command-Line Debugger, and a More Capable REPL

The headline here is a new command-line debugger for Robot Framework. robotcode robot-debug (alias run-debug) runs a real suite through the normal runner and pauses where you tell it to — a file and line, a keyword name, an embedded Breakpoint keyword, the first failure, or right at entry. Once it stops, you get a pdb-style prompt with the live call stack and variables, where you can step through execution, inspect and set variables, evaluate expressions, manage breakpoints, and run keywords in the paused context. It works on every supported Robot Framework version and runs in terminals, over SSH, and in containers where the VS Code debugger isn't an option — and an AI agent can drive it non-interactively to capture the exact state at the moment of failure.

robotcode robot-debug --break login.robot:42 tests/
robotcode robot-debug --stop-on-entry tests/login.robot

The same debugger is available inside robotcode repl, but there it starts detached and the shell stays a shell: a failing keyword just prints its error and leaves you at the prompt. Attach it (.debug on, or start with --break) when you actually want to stop on a breakpoint, and the breakpoints you set survive toggling it back off.

Alongside the debugger, robotcode repl itself has grown into a far more comfortable scratchpad. It keeps command history across sessions, completes keywords, variables, and imports as you type, and handles multi-line blocks. .kw and .doc show the same keyword and library documentation the editor surfaces on hover, right in the terminal, in a scrollable viewer with search and clickable links. Imports work just like in a suite — type Library, Resource, or Variables at the prompt — ${_} holds the last keyword result, and .save exports a session as a runnable .robot file. A --plain mode keeps the output clean for scripts and AI-agent workflows.

For the full guide — every dot-command, the complete debugger command set, and installation extras — see the REPL and command-line debugger references.

AI and Agent Workflows

The commands in the sections above weren't built only for people at a keyboard — a big motivation was letting AI agents operate a Robot Framework project from the same structured, project-resolved output.

Chat Plugins for AI Agents

RobotCode now ships a set of chat plugins that teach an AI agent to operate a Robot Framework project through the project's own robotcode CLI, the way an experienced Robot Framework engineer would. The agent honors your robot.toml, profiles, and Python environment, so it works with the same resolved view of your project that the rest of RobotCode uses. The plugins are published as a marketplace, robotframework-agent-plugins, so any Open-Plugins-compatible agent — Claude Code, Codex, GitHub Copilot, and others — can install them once and reuse them anywhere. For example, you can ask it to:

"run the smoke tests with the ci profile" — runs them through the selected profile and reports pass/fail counts
"why did Login Works fail?" — inspects the existing run results with robotcode results
"what tests and tags exist?" — uses robotcode discover to resolve the real set (paths, profiles, variables, pre-run modifiers)
"what arguments does this keyword take?" — looks it up with libdoc against the installed libraries and local resources
"try this keyword" — runs it in the REPL

For agents running outside VS Code, the plugins call the robotcode CLI directly, so it needs to be installed in the project's Python environment.

Inside VS Code there's nothing to install: the extension bundles both the chat plugins — for GitHub Copilot Chat — and robotcode itself, making the bundled CLI available in the integrated terminal through VS Code's terminal shell integration, so the plugins work out of the box. They are enabled by default and can be toggled with robotcode.ai.enableChatPlugins.

If you would rather install the plugins from the marketplace inside VS Code, two new Command Palette commands — RobotCode: Add Chat Plugins Marketplace and RobotCode: Remove Chat Plugins Marketplace — register or remove the marketplace in your user-level chat.plugins.marketplaces setting without editing JSON by hand. Only the applicable command is shown depending on whether the marketplace is already registered. When you install the plugins this way, turn off robotcode.ai.enableChatPlugins so you do not run the bundled and marketplace copies at the same time.

For installation, marketplace setup, and troubleshooting, see Working with AI Agents.

VS Code Chat Tools Are Deprecated

The existing VS Code chat language model tools for Robot Framework keyword documentation, library documentation, imports, and environment details are now deprecated and disabled by default in favor of the CLI-based chat plugins described above. If you still rely on them during the transition, enable robotcode.ai.enableLanguageModelTools; the setting remains visible for now.

Cleaner Output in AI-Agent Sessions

RobotCode now recognizes common AI-agent environments and keeps terminal output easier to capture. Colors, paging, and REPL prompt enhancements are toned down by default in those sessions, so chat tools get clean text instead of terminal control sequences. Explicit CLI flags and environment variables still override the defaults; see AI-agent detection.

Experimental SemanticModel Preview

This release introduces the first experimental version of the SemanticModel, a new analysis foundation that RobotCode will use to understand Robot Framework files more deeply and more consistently.

This is the analysis-foundation part of the release, and it is intentionally not finished yet. The long-term plan is to replace the old analysis path with a single pre-computed model of the file: keyword calls, variables, imports, control flow, settings, references, and token meaning all resolved once, then reused by editor features. That should eventually mean less duplicated AST walking, fewer subtle differences between features, and better building blocks for things like completions, hover, rename, and future navigation features.

For v2.6.0, the SemanticModel is a preview behind an opt-in flag. Parts of the migration are already in place, and the migrated features are designed to behave the same as the default analyzer. This is still early in the migration, so the default analyzer remains the recommended path while the new model gets more real-world mileage.

Enable it in robot.toml:

[tool.robotcode-analyze]
semantic-model = true

or in VS Code:

"robotcode.experimental.semanticModel": true

With the SemanticModel enabled, RobotCode can already statically resolve more nested variables such as ${DICT_${key}} and handle RF 7.4 KeywordName and KeywordArgument type hints for run-keyword detection.

Some editor features now have SemanticModel-backed paths:

Inlay hints read pre-resolved data instead of doing a second analysis pass.
Signature help can use already-resolved keyword data.
The "Open Documentation" code action can read keyword and token information from the model.
The "Create Keyword" quick fix and "Assign Result to Variable" refactor can use the keyword call's resolved namespace, library entry, and assignment state.

The intended result is that normal editor output stays the same while the internals get stronger. Dedicated equivalence tests already compare old and new paths across supported Robot Framework versions, but this is still a work in progress, not a stability promise.

The feature is disabled by default while it matures. If you are curious and enable it on your project, we would love to hear how it behaves for you, especially if you notice differences from the default analyzer. Real project feedback is exactly what will help turn this new foundation into the normal path later. The full robot.toml setting is documented in the configuration reference.

Documentation for Agent-Friendly Workflows

A lot of the release work went into documentation for those agent-friendly workflows too. There are new or heavily expanded guides for AI-agent workflows, run-result inspection, project discovery, static analysis, the REPL and command-line debugger, plus refreshed CLI and robot.toml references. The goal is the same as the tooling work: make the real project behavior easier to inspect, follow, and automate.

CLI and VS Code Polish

Smoother Test Explorer Refreshes

The VS Code Test Explorer is calmer and more responsive during active editing. It now avoids re-rendering the tree when discovered tests have not actually changed, batches bursts of file edits into a single workspace refresh, cancels in-flight discovery when newer edits arrive, and keeps expanded tree nodes open when external file changes are detected.

Newly added or removed tests in saved files now appear or disappear immediately without needing the refresh button. The same work also removes a startup edge case where AbortError could briefly show up as a workspace entry.

Cleaner Terminal Colors

CLI coloring now follows terminal conventions more closely. ANSI colors are auto-disabled when output is redirected to a pipe, file, log capture, or CI artifact, while NO_COLOR and FORCE_COLOR are respected. stdout and stderr are decided independently, so warnings can still stay colored when stdout is piped but stderr is still attached to a terminal. Explicit --color and --no-color still override auto-detection. This stream-based handling is separate from the AI-agent output tuning above: one reacts to where output goes, the other to who is reading it.

Control the What's New Notification

VS Code users can now turn off the update notification shown after RobotCode updates. The setting is available as robotcode.showWhatsNewOnUpdate under RobotCode > General. The What's New post is still there when you want it; the notification just no longer has to appear after every update.

Real `robot.toml` Examples in the Schema

The robot.toml reference and JSON schema now include real TOML examples and clearer inline documentation. The schema is also available from its new public URL, https://www.robotcode.io/schemas/robot.toml.json, so editor tooling can show more useful examples while you configure profiles, paths, variables, analysis settings, and runner options.

Bug Fixes

There are also a few focused fixes in this release:

CLI unused-variable diagnostics now treat variables starting with _ as intentionally unused, matching the language server behavior. (#593)
The environment-validation quick pick in VS Code now mentions the correct minimum Robot Framework version, 5.0 instead of the stale 4.1 text. Thanks to Danilo for the PR! (#603)
When VS Code's "4 Spaces Tab" setting is enabled, Tab now still accepts Copilot inline edit suggestions instead of always inserting spaces. (#566)
robot.toml now accepts max-error-lines = "NONE", matching Robot Framework's --maxerrorlines NONE spelling for showing the full error message. (#606)

Thank You

Thanks to everyone who reported issues and contributed ideas — and to everyone who uses RobotCode in their daily work. Your feedback drives every release.

For the full list of changes, see the Changelog.

What's New in v2.5.1

Thu, 02 Apr 2026 00:00:00 GMT

A quick follow-up to v2.5.0 with three bugfixes that came in from your reports — thanks for filing them.

Template Keywords No Longer Flag Embedded Arguments as Unresolved

If you use [Template] or Test Template with a keyword that has embedded arguments — something like The result of ${calculation} should be ${expected} — RobotCode was treating the embedded argument placeholders as unresolved variables and showing false VariableNotFound diagnostics.

This happened because the analyzer didn't distinguish between regular variable references and embedded argument placeholders when the keyword call came from a template declaration. Fixed: embedded argument tokens in template contexts are now skipped during variable analysis. (#542)

Multi-Word BDD Prefixes Now Match Correctly

Languages with multi-word BDD prefixes — most notably French with prefixes like Étant donné que, Et que, and Mais que — weren't always recognized correctly. The problem: shorter prefixes (e.g. Et) matched before longer ones (e.g. Et que), consuming the prefix too early and leaving the keyword name garbled.

RobotCode now sorts prefixes by length (longest first) and uses a single compiled regex for matching, which is the same strategy Robot Framework itself uses internally. This applies to keyword resolution, BDD prefix stripping, and semantic token highlighting. (#560)

`${CURDIR}` Works Correctly in Variable Values on Windows

The ${CURDIR} variable in resource file variable tables was broken on Windows due to inconsistent backslash escaping. The resource builder used quadruple backslashes (\\\\) while the namespace analyzer used double backslashes (\\), and neither was correct for all cases.

Both code paths now share a single replace_curdir_in_variable_values() helper with consistent escaping. (#589)

Thank You

Thanks to everyone who reported these issues — your bug reports make RobotCode better for the whole community.

For the full list of changes, see the Changelog.

What's New in v2.5.0 (April 1st Edition)

Wed, 01 Apr 2026 00:00:00 GMT

Hello everyone,

we're excited to share a big RobotCode release with you today. As many of you know, the main focus of v2.5.0 has been on performance — analysis caching, faster keyword resolution, smarter code completion. But while working on those features, we discovered some surprising opportunities that we just couldn't leave on the table. Here's the full picture.

Predictive Analysis Caching

You already know that RobotCode now caches analysis results in a local SQLite database for instant startup. But we didn't stop there.

The new Predictive Caching engine uses your git history, file modification patterns, and time-of-day statistics to pre-analyze files you're likely to open next. If you usually start your Monday mornings in the login test suite, RobotCode has those results ready before you even open the file.

It also watches your keyboard idle patterns. Extended pauses after writing a FOR loop typically mean you're about to switch to a different file for reference — so RobotCode pre-caches the top 5 most probable navigation targets during those pauses.

Configure prediction depth in robot.toml:

[tool.robotcode-analyze.cache]
prediction-depth = "clairvoyant"  # options: "conservative", "optimistic", "clairvoyant"

Proactive Performance Mode

The performance improvements in v2.5.0 (94% faster keyword matching, 28% faster file resolution) were so effective that we ran into an unexpected problem: RobotCode now finishes analysis before some editors are ready to receive the results.

To address this, we've added Proactive Performance Mode. When enabled, RobotCode uses the leftover time between analysis completion and editor readiness to perform speculative work:

pre-resolving keywords from libraries you haven't imported yet but statistically might
warming up code completion for keyword arguments you're likely to type based on cursor position history
pre-computing diagnostics for code you haven't written yet, based on how similar keyword calls usually end

This occasionally leads to diagnostic warnings appearing for lines that don't exist yet. This is expected behavior and usually means you were going to make that mistake anyway.

Emotional Code Completion

The new type hint-based completion for Literal values turned out to be just the beginning. Our analysis of completion acceptance rates revealed that keyword suggestions are significantly more effective when they match the developer's current emotional context.

RobotCode now analyzes several signals to determine your coding mood:

typing speed and error correction frequency
time since last successful test run
number of times you've hovered over the same unresolved keyword
current scroll velocity (fast scrolling = frustration, slow scrolling = contemplation)

Based on this, code completion now adjusts its suggestions:

Confident mode: shows advanced keywords, complex argument patterns, embedded arguments
Cautious mode: prioritizes well-tested keywords with high call frequency in your workspace
Frustrated mode: moves Sleep and Log To Console to the top of every completion list
Resignation mode: suggests [Tags] known-issue and Skip Not today

Keyword Adoption Program

Finding unused keywords with robotcode analyze code --collect-unused was a much-requested feature. But simply listing unused keywords felt incomplete. These keywords were written by someone, probably with good intentions, possibly on a Friday afternoon. They deserve better than a cold diagnostic message.

RobotCode now offers the Keyword Adoption Program. When an unused keyword is detected, instead of just flagging it, RobotCode:

checks if any other workspace in your organization could use it (via the new optional Keyword Sharing Protocol)
generates a short "keyword biography" describing when it was written, how many times it was called in happier times, and what it probably hoped to achieve
suggests test cases where it could be useful, even if nobody asked

Keywords that remain unadopted for more than 30 days receive a farewell message in the Problems panel before being eligible for cleanup.

You can sponsor a keyword to prevent its removal:

[tool.robotcode-analyze.code]
sponsored-keywords = ["Click All The Things", "Verify Everything Is Fine"]

Cache Mood Indicators

The new robotcode analyze cache CLI commands give you full control over your analysis cache. But raw statistics felt impersonal, so we've added a Cache Mood indicator.

Your cache now has feelings:

$ robotcode analyze cache info
Cache status: 😊 Content (2,847 entries, 98.2% hit rate)

Possible moods:

😊 Content — high hit rate, low invalidation, everything is in harmony
😐 Indifferent — moderate hit rate, cache is doing its job but doesn't feel appreciated
😟 Anxious — frequent invalidations, the cache is worried it might not be needed anymore
😤 Frustrated — constant cache misses, usually caused by rapidly changing files, the cache would like you to please make up your mind
💔 Heartbroken — you ran cache prune, the cache remembers everything that was lost

Running cache prune followed by cache info now shows a brief memorial of what was deleted, including the oldest entry's creation date and a message like "It had been with you since Tuesday."

The new workspace-wide ProjectIndex tracks references between keywords, variables, and namespaces. Internally, this is a straightforward inverse index. But we realized the data maps surprisingly well to social network concepts.

The new Keyword Social Graph (available via robotcode analyze social) shows:

Popularity: which keywords are called by the most test cases
Influence: keywords whose failure would cascade to the most other tests
Cliques: groups of keywords that are always used together and never separately
Loners: keywords with zero incoming references (see: Keyword Adoption Program above)
Frenemies: keyword pairs that are frequently used in the same test but never in the same keyword call — suggesting an unresolved tension

Keywords with high influence automatically receive a [Critical] badge in code completion. Keywords in the "Loners" category get a 💬 icon suggesting they "reach out" to nearby test cases.

Known Limitations

Predictive caching defaults to "clairvoyant" on Fridays, which can cause unexpected cache entries for files in branches you haven't checked out yet
Emotional code completion cannot detect sarcasm in keyword names
The Keyword Adoption Program does not yet support cross-company adoption due to GDPR concerns
Cache mood indicators are not yet configurable and may not reflect your own feelings about the cache
robotcode analyze social --include-drama is available but not recommended in production environments
The keyword social graph may reveal uncomfortable truths about your project's architecture

Breaking Changes

Cache entries now have feelings and may resist deletion if recently populated
Keyword completion order may vary depending on your emotional state
Running cache prune now prompts "Are you sure?" followed by "Are you really sure?" followed by a 5-second countdown

Migration Guide

No manual migration is required. However, we recommend:

giving your team a heads-up about the keyword biographies before someone gets emotional
reviewing your CI pipeline expectations around cache mood
not running robotcode analyze social --include-drama during sprint reviews
checking the date before filing issues about any of the above

What Actually Changed

Happy April 1st! 😄

None of the above features exist. Probably for the best. But there is a real v2.5.0 release — and it's actually worth reading.

👉 Read the real release notes here 👈

What's New in v2.5.0

Tue, 31 Mar 2026 00:00:00 GMT

If you've ever opened a large Robot Framework project and gone for coffee while RobotCode was still thinking — this release is for you. Version 2.5.0 is all about speed: faster startup, faster analysis, faster code completion. And a few new tricks on top.

Instant Startup with Analysis Caching

The biggest change you'll notice: RobotCode remembers. When you open a project for the second time, all the analysis work from your last session is still there — diagnostics, code completion, navigation, everything loads almost instantly.

Behind the scenes, RobotCode now stores fully resolved analysis data in a local SQLite database. Instead of re-analyzing every file on every IDE start, it loads cached results and only re-processes files that actually changed. For projects with hundreds of Robot files, this can cut startup from minutes down to seconds.

This is enabled by default — there's nothing to configure. The cache is automatically invalidated when your source files change, when library dependencies are updated, when environment variables or command-line variables differ, or when you update RobotCode itself. If something changes, the affected parts are re-analyzed — everything else comes straight from cache.

Since this is a new feature, you can disable it if you run into any issues:

robot.toml

[tool.robotcode-analyze.cache]
cache-namespaces = false

or via the CLI:

robotcode analyze --no-cache-namespaces

Multiple processes (the language server, CLI commands, parallel analyze runs) can safely access the cache at the same time thanks to file-level locking. No corruption, no conflicts.

Performance: The Numbers

Even without the cache, this release is noticeably faster. Here's what changed:

No more 30-minute hangs on large projects. Robot Framework's variable_not_found runs a fuzzy "Did you mean…?" search on every unresolved variable — a nice idea, but O(n×m) over all variable candidates. For big projects (375+ files), this could freeze the analysis for over 30 minutes. RobotCode now skips that search entirely since it never uses the suggestion text. Problem solved. (#587)
Keyword matching is 94% faster. The KeywordMatcher used to be instantiated from scratch on every lookup — about 7.5 million times per analysis run. It's now cached on the KeywordDoc itself. Combined with a new dict-based index in KeywordStore, keyword lookups went from linear scan to O(1) for non-embedded keywords. Overall analysis time dropped by 22% with 31% fewer function calls.
File resolution is 28% faster. Swapping pathlib.Path for os.path string operations in the hot path of file resolution plus lazy-caching of valid sys.path entries cut warm-start wall time by nearly a third.
Less memory per document. Each document used to keep two cached AST models. Now there's just one, saving around 200–500 KB per file. That adds up quickly in a big workspace.
Faster cache loading. Cached namespace data now includes source hints that let RobotCode skip expensive filesystem lookups (find_resource) when the cached paths still exist on disk. Cache entries use lazy deserialization — data blobs are only unpickled on actual cache hits, not on every lookup.
ArgumentSpec.resolve() actually caches now. A subtle bug caused RobotArgumentSpec to be recreated on every call (100K times per run) instead of being cached. Fixed — instantiation calls dropped by 98.7%.

Smarter Code Completion for Type Hints

If you write Python libraries with type hints like Literal["fast", "slow", "auto"], RobotCode now picks up on those and shows the allowed values directly in the completion list. This works for Union types containing Literal too, so Literal["x", "y"] | int will offer x and y as suggestions.

No more switching to the library docs just to look up which string values a keyword accepts — the editor tells you right there.

Find Unused Keywords & Variables from the CLI

Unused keywords and variables are the kind of thing that quietly accumulates in any project. RobotCode can now detect them when running robotcode analyze code from the command line — great for CI pipelines or periodic cleanup sessions.

Enable it in your robot.toml:

[tool.robotcode-analyze.code]
collect-unused = true

Or toggle it per invocation:

robotcode analyze code --collect-unused
robotcode analyze code --no-collect-unused

Full Control over the Analysis Cache

A new robotcode analyze cache command group gives you visibility into what's cached and lets you manage it when needed:

robotcode analyze cache path     # where is the cache stored?
robotcode analyze cache info     # cache statistics, per-section breakdown
robotcode analyze cache list     # list cached entries (supports glob filtering with -p)
robotcode analyze cache clear    # remove cached entries by section
robotcode analyze cache prune    # wipe the entire cache

All output respects --format (text/json/toml) and --no-color, so it plays nicely with scripts and CI.

You can also point the cache to a custom directory via the ROBOTCODE_CACHE_DIR environment variable. The VS Code extension automatically sets this in the integrated terminal, so your CLI commands and the language server always share the same cache without any manual setup.

Bug Fixes

Fixed cache validation for libraries imported via relative paths — no longer triggers unnecessary full rebuilds on warm start.
Variable names with trailing = are now stripped correctly by the resource builder (#546).
RobotCode no longer overrides the source field on AST blocks when Robot Framework itself already sets it (#588).
Fixed a race condition when accessing workspace language settings in multi-workspace setups.

Under the Hood

A lot of internal work went into this release to prepare for future features:

Workspace-wide reference index (ProjectIndex) — RobotCode now maintains an incrementally updated inverse index across your entire workspace. When a file changes, only its references are updated instead of scanning everything. This covers keywords, variables, namespace entries, keyword tags, testcase tags, and metadata. This is the foundation for upcoming features like unused import detection, import dependency visualization, and call hierarchy — stay tuned.
Namespace refactoring — The old monolithic Namespace class has been split into a clean data container (Namespace DTO) built by a dedicated NamespaceBuilder, with separate modules for import resolution, AST analysis, variable scoping, and scope trees. This makes the codebase more maintainable and easier to extend.
RF_VERSION constant — All ~134 scattered get_robot_version() call sites have been replaced with a single module-level constant. All dead code for Robot Framework < 5.0 (which is no longer supported) has been removed.
JSON file watching — .json files are now included in the watched file extensions, so changes to JSON-based configuration are picked up automatically.
Deprecated Robocop options removed — Legacy robocop configuration options that were deprecated in earlier releases have been cleaned up.

Thank You

Thanks to everyone who reported issues, contributed ideas, and tested pre-release builds. Your feedback drives every release.

For the full list of changes, see the Changelog.

RobotCode | News

What's New in v2.8.0

Highlights

Breaking Changes

Robot Framework 7.5 Support

Richer Keyword Documentation

Test and Task Metadata

Also on Robot Framework 7.5

VS Code

Documentation Viewer

The Python Environment

Test Runs in RobotCode's Own Terminal

See Where a Test Failed

Also in VS Code

PyCharm

Language Server and Analysis

More Robust Library Loading

Cleaner Keyword Completion

Also in the language server and analysis

AI Agents

Command Line and REPL

robotcode doc

A More Dependable REPL

Also on the command line

A New Website

Python 3.15

Nightly Builds

Bug Fixes

Under the Hood

Thank You

What's New in v2.7.0

Run Tests Through a Wrapper

A Trustworthy Analysis Cache

Bug Fixes

Thank You

What's New in v2.6.2

v2.6.2

v2.6.1

Thank You

What's New in v2.6.0

Inspect Robot Framework Runs from the Terminal

Searchable Project Discovery

CI-Ready Static Analysis Output

A Command-Line Debugger, and a More Capable REPL

AI and Agent Workflows

Chat Plugins for AI Agents

VS Code Chat Tools Are Deprecated

Cleaner Output in AI-Agent Sessions

Experimental SemanticModel Preview

Documentation for Agent-Friendly Workflows

CLI and VS Code Polish

Smoother Test Explorer Refreshes

Cleaner Terminal Colors

Control the What's New Notification

Real robot.toml Examples in the Schema

Bug Fixes

Thank You

What's New in v2.5.1

Template Keywords No Longer Flag Embedded Arguments as Unresolved

Multi-Word BDD Prefixes Now Match Correctly

${CURDIR} Works Correctly in Variable Values on Windows

Thank You

What's New in v2.5.0 (April 1st Edition)

Predictive Analysis Caching

Proactive Performance Mode

Emotional Code Completion

Keyword Adoption Program

Cache Mood Indicators

ProjectIndex: The Keyword Social Network

Known Limitations

Breaking Changes

Migration Guide

What Actually Changed

What's New in v2.5.0

Instant Startup with Analysis Caching

Performance: The Numbers

Smarter Code Completion for Type Hints

Find Unused Keywords & Variables from the CLI

Full Control over the Analysis Cache

Bug Fixes

`robotcode doc`

Real `robot.toml` Examples in the Schema

`${CURDIR}` Works Correctly in Variable Values on Windows