ColdFusion Builder Extension for Visual Studio Code Update 5

Last update:

May 18, 2026

Explore new ColdFusion Builder Extension for VS Code features, including smarter IntelliSense for CFML, Docker workflows, and Linux support.

VS Code plugin support on Linux

The ColdFusion Builder extension for VS Code now officially supports Linux environments, including Ubuntu desktops, remote Linux systems accessed over SSH, and WSL2. This release brings feature parity across Linux, Windows, and macOS, enabling developers to use the same workflows and capabilities regardless of platform.

With official Linux support in place, you can:

Install and run the ColdFusion Builder extension natively on Linux

Configure and manage ColdFusion servers directly from VS Code

Use core productivity features such as code assist, navigation, and project workflows

Debug ColdFusion applications across local, remote, and containerized server environments

No additional setup or platform-specific workaround is required beyond the standard extension installation and configuration process. To ensure smooth project access and workspace operations, project directories and associated workspace locations should have appropriate read, write, and execute (rwx) permissions for the current user.

The Linux support update also improves cross-platform debugging consistency. The extension now correctly handles Linux-specific file path behavior, including case-sensitive path resolution, ensuring reliable breakpoint mapping and stable debugging sessions across supported server environments.

For example, on Ubuntu, developers can open a ColdFusion project in VS Code, start a debugging session, and work with applications using the same streamlined experience available on Windows and macOS.

Docker compatibility in the ColdFusion Builder Extension for VS Code

The ColdFusion Builder extension for VS Code now supports ColdFusion servers running in Docker as first-class development targets. Developers can register Docker-based servers, associate them with projects, map local project directories to container paths, and run or debug CFML directly against containerized environments. This enables streamlined container-based development workflows while helping maintain consistency between development and production setups.

What you can do now

With Docker support enabled in the extension, you can:

Register a ColdFusion server running inside a Docker container
Associate and manage projects mapped to Docker container paths

Run .cfm files directly against the containerized server

Debug CFML code running inside Docker

Use RDS features such as file browsing, data views, and with Docker-based servers

Set up a Docker-based ColdFusion server in VS Code

The ColdFusion Builder extension for VS Code allows you to configure Docker-based ColdFusion servers as remote development targets. This enables running, debugging, and managing ColdFusion applications directly against containerized environments.

Example: running ColdFusion in Docker

docker run -dt \

  -e acceptEULA=YES \

  -e installModules=all \

  -e password=admin \

  -p 8500:8500 \        # ColdFusion HTTP port

  -p 5005:5005 \        # ColdFusion debugger port

  -p 5005:5005 \        # Debugger server port used by VS Code

  --name cf25 \

  adobecoldfusion/coldfusion:latest

Note: The flag-Ddebugger_server_port=portNumber needs to be added in Docker's jvm.config. Additionally, you must open the ports mentioned for smooth functioning of servers in Docker.

Use a debugger server port that is different from the ColdFusion debugger port to avoid conflicts when connecting from VS Code.

Configure the Docker server

After starting the container:

Add a new server from Server Manager with the following configuration:
1. Server type: ColdFusion + Tomcat bundle
2. Type: Is Remote
3. Docker: Enabled
4. Host and port values matching the container configuration
5. Map the local project directory to the corresponding remote directory inside the container
6. Debugger and RDS settings configured as required
7. Document root mapped to the corresponding project directory inside the container

The document root mapping allows the extension to associate files in your local workspace with their corresponding paths inside the Docker container.

Manage projects with Docker mapping

Once the Docker server is configured, create or import projects with the containerized server using mapped local and container paths. This allows the Project Manager to work seamlessly with files stored locally while executing against the ColdFusion server running inside Docker.

With project mapping configured, you can:

Create and manage ColdFusion projects in VS Code
Edit local project files and run them against the Docker server
Maintain consistency between local development and containerized execution environments

Run and debug CFML applications in Docker

After configuring the Docker server and project mapping:

Open a .cfm file in VS Code.
Right-click and select Run as ColdFusion Application.

The extension sends the request to the configured Docker-hosted ColdFusion server, such as:

http://localhost:8500/

If the local project structure matches the configured container document root, the correct file is executed inside the container.

To debug CFML code:

Ensure the debugger port is exposed and configured in the container.
Set breakpoints in your CFML files.
Start a debug session using the configured Docker server.
Right-click and select Debug as ColdFusion Application.

VS Code connects to the ColdFusion debugger running inside the container, allowing you to inspect variables, step through code, and continue execution as with a standard remote server configuration.

Use RDS with Docker

RDS integration is also supported for Docker-based ColdFusion servers. Once RDS credentials are configured for the server, you can use:

RDS File View
RDS Data View

To enable these features:

Ensure RDS is enabled in the ColdFusion container
Expose the HTTP port used by ColdFusion
Verify that /CFIDE is accessible through the mapped container port

After configuration, VS Code can interact with the ColdFusion instance inside Docker for file browsing, datasource inspection, and service exploration.

Remove workspace and project dependency

The ColdFusion Builder Extension for VS Code now automatically manages workspaces, allowing developers to create and import ColdFusion projects without manually creating or opening a workspace. Internally, workspaces are still used, but they are created or opened automatically in the background when needed. This simplifies project setup and aligns the extension with standard VS Code workflows, reducing onboarding friction and allowing developers to focus on working with projects rather than managing workspace mechanics.

What you can do now

Create new ColdFusion projects without manually creating or opening a workspace
Import existing ColdFusion Builder projects without being prompted for workspace selection
Reuse existing workspaces and projects as before by opening them later from the File menu

Workspace files are stored automatically at a standard location (for example, /Code/cfWorkspaces) without requiring user interaction. This provides a consistent internal structure while keeping the workflow simple for users.

Code assist for member functions on primitive types

The ColdFusion Builder Extension for VS Code now provides enhanced code assist for member functions on primitive data types such as strings, arrays, and structs. Member functions are suggested reliably on variables and literal expressions, including inline, multi‑line, and chained calls. This improves Intellisense accuracy and aligns editor behavior more closely with native ColdFusion language capabilities.

Code assist determines the appropriate suggestions by inferring the return type of the preceding expression. This behavior applies consistently across inline expressions, multi‑line calls, and chained method calls.

With the improved code assist, you can:

Invoke member-function completion directly on literal values

Use IntelliSense reliably with multi-line data and expressions

Chain member-function calls with accurate type-aware suggestions at each step

These capabilities work consistently across common CFML coding styles. Member functions on literal expressions. Member functions are suggested directly on primitive literals.

"hello".<caret>        // string member functions 

[1, 2].<caret>         // array member functions 

{a:1, b:2}.<caret>     // struct member functions

This applies to both single‑line and multi‑line literals.

Multi‑line literals

[ 

  1, 

  2 

].<caret>

Multi‑line method calls

getCloudService( 

  cred, 

  conf 

).<caret>

Method chaining

"hello" 

  .trim() 

  .toUpperCase() 

  .<caret>  

[1, 2, 3] 

  .map(function(x) { return x * 2; }) 

  .filter(function(x) { return x > 3; }) 

  .<caret>

These enhancements bring CFML code assist in VS Code closer to the language’s full capabilities, supporting expressive, modern coding patterns while maintaining accurate and context-aware IntelliSense.

Code assist for struct parameters for AI features

ColdFusion Code Assist now provides enhanced support for struct-based parameters used across AI features. As you configure AI-related APIs and services, Code Assist helps by suggesting supported struct keys, auto-populating required parameters, and providing inline guidance for valid configuration patterns.

Key capabilities include:

Required struct keys are auto-populated when the struct suggestion provided by code assist is selected.
Additional supported keys are suggested as you type.
Suggested parameters can change dynamically based on selected values.
Parameter descriptions and documentation can be viewed using Ctrl + Space, similar to other attribute assistance in the editor.

For example, when configuring a ChatModel, supported parameters vary depending on the selected provider. If the provider is set to anthropic, parameters such as stopsequences are suggested, while excluded for providers such as openai.

chatModelObj = ChatModel({

    provider = "anthropic",

    modelname = "claude-sonnet-4.6",

    responseformat = "JSON",

    stopsequences = stopsequences

});

More examples

chatModel = ChatModel( { <caret> })

chatModel = ChatModel( {

        provider = "anthropic",

        <caret>

    })

chatModel = ChatModel( {

        provider = "<caret>"

    })

As you add each key, Code Assist:

Recommends valid parameter names such as provider, modelname, and responseformat
Auto-populates required values (for example, supported providers and models)
Maintains correct struct schema

Code Assist adapts suggestions based on the selected provider and previously used parameters, reducing manual lookup and schematic errors.

Code assist for cloud and MongoDB functions

ColdFusion Builder Extension for VS Code now includes enhanced Code Assist support for Cloud and MongoDB functions. Developers receive intelligent suggestions, inline documentation, parameter assistance, and improved auto-completion for cloud integrations and MongoDB functions.

For Cloud services, Code Assist provides service-specific suggestions. The service name is defined in the Cloud configuration struct, which can exist in either the local or application scope.

For MongoDB, the NoSQL databases configured in the ColdFusion Administrator are fetched, and based on those configurations, suggestions are provided for databases and collections.

Syntax highlighting changes

Resolved syntax-highlighting issues caused by standalone # characters or <cfif> tags inside <script> blocks, which previously affected parsing across the file.
Introduced a context-aware CFML grammar that accurately differentiates CFML from HTML, CSS, JavaScript, and SQL within mixed-language files.
Added a CFML-aware JavaScript grammar in place of the default VS Code implementation, enabling proper handling of CFML tags inside <script> blocks.

Indicators for deprecated and removed functions and tags

ColdFusion now distinguishes deprecated and removed tags and functions in the code editor by displaying them with a strikethrough style.When you use legacy ColdFusion tags or functions that are no longer supported, the editor clearly marks them as struck through, making it easy to identify outdated APIs directly in your code. This applies consistently across:

Deprecated and removed CFML tags
Deprecated and removed CFScript functions

This visual indicator helps you:

Quickly spot legacy code during development or modernization efforts
Avoid introducing deprecated APIs into new code
Migrate existing applications to supported alternatives with greater confidence

When hovering over deprecated syntax, the extension now also displays the recommended remediation steps to help resolve the issue quickly. Include a corresponding image illustrating the hover message and suggested fix.

The enhancement improves code readability and encourages adoption of current, supported ColdFusion features—without requiring additional tooling or documentation lookups.

Figure: Strikethrough in deprecated tags and functions

Revamped Security Analyzer

Security Analyzer in VS Code extension adds new vulnerability detection (NoSQL, command, LDAP, XPath, template, expression language, API, cryptography, business logic, unscoped variables), improves scan speed and accuracy, reduces false positives, supports large projects, lowers memory use, and offers granular filters, export options, and customizable rules for modern security workflows.

Bug fixes in this update

This release also includes multiple stability, correctness, and localization improvements that enhance the overall reliability and developer experience of the ColdFusion VS Code extension across platforms and languages.

Bug ID	Description
CFBVSCODE-829	When you use a lone # character in pure HTML (for example inside an SVG <use xlink:href="#icon-id">), the VS Code formatter for CFML treats it as if it starts a ColdFusion expression, even though it’s not inside <cfoutput>. As a result, once the formatter hits that #, it reformats the rest of the file incorrectly. Adding a dummy comment like <!--- # ---> after the HTML fixes the formatting, which shows that the extension is mis‑detecting that # as CFML.
CFBVSCODE-822	The ColdFusion Builder VS Code extension does not fully or correctly localize some Japanese UI text. Several context menu items and configuration descriptions never appear in Japanese at all, so those entries fall back to English.
CFBVSCODE-820	If you put an HTML closing tag like </a> inside a JavaScript string within a <script> block, the extension’s parser wrongly treats </a> as a real HTML close tag instead of part of the string.
CFBVSCODE-816	When you write an include like: <cfinclude template=arguments.targetPage> the linter assumes you’re doing something wrong and complains that the CFM file name is “missing” or invalid, even though the code is perfectly legal ColdFusion and will run correctly. It expects the template to be a quoted string.
CFBVSCODE-814	ColdFusion supports function “pre‑body” annotations and custom metadata in CFScript (for example, annotation‑style metadata before the function body). The VS Code extension doesn’t fully understand this syntax. When you use these pre‑body constructs, the code analyzer effectively stops analyzing the rest of the file.
CFBVSCODE-781	On Linux, the extension looks for VS Code’s settings.json file in the wrong path, something like /home/user.config/Code/User/settings.json instead of the correct /home/user/.config/Code/User/settings.json. Because of this, the extension throws an error saying the settings file is corrupted or unreadable, when it’s just looking in the wrong directory.
CFBVSCODE-542	When you embed CFML conditionals with scoped variables inside a <script> tag, the VS Code extension’s syntax highlighter loses track of the structure. It incorrectly colors the <script> and </cfoutput> tags and breaks highlighting for the surrounding HTML/CFML, even though the code itself is valid.
CFBVSCODE-539	With the ColdFusion VS Code extension enabled, you can fold the whole switch block, but cannot fold individual case sections anymore. VS Code’s default behavior (folding each case independently) stops working; only the outer switch remains collapsible, even though each case contains foldable code.
CFBVSCODE-824	When you embed CFML variables like #local.joinCondition# or #tablename# inline inside SQL, either in a <cfquery> body or in a queryExecute() SQL string, the CFML grammar sometimes mis‑parses those lines, especially when the #var# sits on its own line.
CFBVSCODE-823	In the VS Code extension’s Japanese UI, some captions (Add Project, Code Assist, Add Server, Services Browser, Import Project) show no Japanese text, while others use wrong words (e.g., “参加する” for Submit, “コンテキストルート” for Cancel, “番号” for No, “情報源” for datasource),
CFBVSCODE-818	When you type inside ## after Japanese characters, the VS Code extension fails to show the built‑in function completion list. For example, in あいう<cfoutput>##</cfoutput>, pressing Ctrl+Space between the hashes doesn’t trigger suggestions, even though code assist works correctly without preceding Japanese text.

Was this page helpful?

We're glad. Tell us how this page helped.

Found the answer to my problem Understood the instructions Liked the feature

Other suggestions

We're sorry. Can you tell us what didn't work for you?

Didn't find the answer to my problem Couldn't understand the instructions Didn't like the feature

Other suggestions

Thank you for your feedback. Your response will help improve this page.

Was this helpful?

We are sorry the content didn't meet your needs.

Share additional feedback to help us improve.

0/255 | Character limit exceeded.

Thank you so much for sharing your feedback!