If you have an existing ColdFusion or Lucee application, one of the first questions you may have about BoxLang is probably not:
“Should I rewrite my application in BoxLang?”
It is much simpler:
“Can BoxLang run the CFML application I already have?”
That was the focus of veteran CFML troubleshooter Charlie Arehart’s session at Into the Box 2026, Getting Started with BoxLang as an Alternative CFML Engine.
And Charlie makes one distinction very clear from the beginning:
This is not a session about converting your CFML code to the BoxLang language.
It is about running your existing CFML code on BoxLang as an alternative runtime to Adobe ColdFusion or Lucee.
For organizations interested in evaluating BoxLang without immediately committing to a major modernization project, that distinction matters.
Here are some of the most important lessons from Charlie’s session.
BoxLang Is a Language — But It Is Also a CFML Engine
One source of confusion around BoxLang is that people often hear about it as a new programming language.
That is true.
But it is only part of the picture.
As Charlie explains, BoxLang can also be thought of as a platform capable of running multiple languages, including CFML.
From the perspective of an organization currently running Adobe ColdFusion or Lucee, the practical takeaway is straightforward:
BoxLang can act as another CFML engine.
You can continue working with your existing .cfm and .cfc applications while running them on the BoxLang runtime.
That means evaluating BoxLang does not require starting by learning a completely new language.
You Do Not Have to Convert Your CFML First
This is perhaps the most important misconception Charlie addresses.
When developers hear that BoxLang can transpile CFML into BoxLang, they may assume they first need to run a migration or conversion process.
They do not.
BoxLang handles that process automatically.
You run your CFML application much as you would on another CFML engine, and BoxLang takes care of the transpilation and compilation under the covers.
That means the starting point can be remarkably simple:
Take the CFML you already have and see how it runs.
If you later want to convert parts of the application into native BoxLang syntax, you can.
But you do not need to do that to begin your evaluation.
The First Question Is: Does Your Code Run?
Charlie reduces the evaluation process to the question that actually matters:
Can BoxLang run your code?
Fortunately, you do not necessarily have to install an entire environment before you start finding out.
One option Charlie demonstrates is TryCF.com, which allows developers to paste CFML code and execute it against multiple CFML engines, including BoxLang.
That makes it useful for quickly checking individual functions, tags, snippets, or behaviors.
You can test a piece of CFML against BoxLang and compare the result with Adobe ColdFusion or Lucee.
There is also CFML Fiddle, an open-source project from James Moberg that can be run locally if you would prefer not to submit code to an online service.
These tools make it possible to begin experimenting before touching a production application.
There Are Multiple Ways to Run BoxLang
Another point Charlie emphasizes is that there is no single required deployment model.
In fact, the number of options can initially feel overwhelming.
BoxLang can be installed directly using its native installer or binary.
For web applications, the BoxLang MiniServer can provide a lightweight web server.
For many CFML developers, however, CommandBox provides one of the easiest ways to begin experimenting because it already offers familiar tooling for launching and managing CFML servers.
But CommandBox is not mandatory.
BoxLang can also be deployed through options including:
- Native BoxLang installation
- BoxLang MiniServer
- CommandBox
- Docker containers
- Kubernetes or other container orchestration
- Servlet containers
- Serverless environments
Charlie mentions servlet containers such as Tomcat, Jetty, JBoss and Undertow, as well as cloud execution models including AWS Lambda and Google Cloud Functions.
The important point is that organizations are not forced into a particular infrastructure architecture simply because they choose BoxLang.
Starting with CommandBox Can Be Surprisingly Simple
Charlie demonstrates the process using something particularly useful: his own long-running CFML website.
Rather than creating a specially prepared demo application, he takes a traditional CFML application and runs it using BoxLang through CommandBox.
The configuration required was small.
His application needed a mapping and a couple of database datasources.
Those settings were defined using a cfconfig.json file.
CommandBox can then read those settings when the server starts.
The server itself is configured through server.json.
Once the configuration was in place, Charlie started the BoxLang-powered server with CommandBox and his existing CFML site came up.
His summary of the process is almost the best advertisement for doing a proof of concept:
The site was old CFML, and it ran.
No application rewrite was required.
Your Application May Already Run Without Compatibility Modules
Another useful clarification from the session concerns BXCompat-CFML.
Developers may assume that running existing CFML automatically requires installing the compatibility module.
That is not necessarily true.
Charlie’s own site ran largely without it.
BoxLang already supports a substantial amount of CFML behavior directly.
The compatibility module becomes useful where applications depend on specific behaviors or quirks associated with Adobe ColdFusion or Lucee.
When that happens, BXCompat-CFML can help bridge those differences.
This makes the migration model more granular than simply declaring an application “compatible” or “incompatible.”
Some applications may run almost immediately.
Others may need a few modules.
And some specific areas may require code changes.
The goal is to identify which category your application falls into.
Modules Fill in Additional Capabilities
BoxLang uses a modular architecture.
Some functionality may therefore require installing additional modules.
Charlie demonstrates this with his SQL Server connection.
Because his website connects to Microsoft SQL Server, he uses the corresponding BoxLang module.
The same principle applies to other capabilities.
This may initially feel unfamiliar to developers accustomed to an installer that includes everything by default, but Charlie points out that modern ColdFusion versions also use a modular architecture for functionality such as PDF generation or mail.
The difference is often simply that users do not see the modules being installed behind the scenes.
With BoxLang, you install the capabilities your application actually needs.
The Feature Audit Tool Can Tell You What You Need
This is one of the most practical parts of Charlie’s session.
Rather than manually opening hundreds or thousands of CFML files and trying to predict compatibility problems, BoxLang includes a Feature Audit tool.
The tool can scan your application and identify:
- Features that may present compatibility issues
- Features supported through additional BoxLang modules
- Areas that may require further review
Charlie runs the audit against his own site.
At first, the output appears intimidating because it scans hundreds of files and reports many occurrences.
But then he uses the aggregate summary option.
Suddenly the analysis becomes much more actionable.
Instead of staring at hundreds of individual findings, he gets a summarized list of the BoxLang modules recommended for the application.
Those modules can then be added to the environment and the application tested again.
That changes the migration process from:
“We have thousands of lines of legacy CFML. Where do we even begin?”
to:
“Let’s scan it, install what it needs, run it, and see what remains.”
That is a much more manageable starting point.
BoxLang Core Can Be Used in Production for Free
Licensing is another area where Charlie deliberately clears up misconceptions.
The core BoxLang runtime can be used for production applications without traditional CPU-core restrictions or SaaS restrictions.
Some commercial modules and capabilities require a BoxLang+ subscription, so whether an organization needs a commercial license depends on the functionality its application uses and the enterprise capabilities it requires.
That also makes the evaluation process easier.
Teams can begin testing the core platform before determining which commercial capabilities they actually need.
You Do Not Need to Decide on a Full Migration Before Testing
Perhaps the strongest lesson from Charlie’s presentation is that evaluating BoxLang does not have to begin as a migration project.
You can start much smaller.
Take a code snippet and test it.
Run the Feature Audit against an application.
Install the recommended modules.
Spin up the application with CommandBox, MiniServer, Docker, or another supported deployment model.
See what works.
Identify what does not.
Measure the effort required.
Only then decide whether moving the application to BoxLang makes sense.
For organizations responsible for large ColdFusion or Lucee systems, that is a far safer way to approach modernization than beginning with assumptions about how difficult the migration might be.
A Practical First BoxLang Proof of Concept
If your team is considering BoxLang, a simple proof of concept could look like this:
- Select one representative CFML application.
- Run the BoxLang Feature Audit against the codebase.
- Review the recommended modules and compatibility findings.
- Configure the application’s mappings and datasources.
- Start the application on BoxLang.
- Test the most important application workflows.
- Document any remaining compatibility gaps.
At that point, you have something far more useful than a theoretical discussion about migration.
You have actual evidence from your own application.
And that is exactly the spirit of Charlie’s session:
Before deciding whether BoxLang can run your CFML application, try running your CFML application on BoxLang.
Watch Charlie Arehart’s Full Into the Box 2026 Session
Charlie walks through this entire process in his 45-minute Into the Box 2026 session, including live CFML compatibility tests, deployment options, CommandBox configuration, his own production CFML website, BoxLang modules, and the Feature Audit tool.
The session is available free on CFCasts as part of the Into the Box 2026 video series.
🎥 Watch “Getting Started with BoxLang as an Alternative CFML Engine” on CFCasts:
https://cfcasts.com/series/into-the-box-2026-video-series/
View the Presentation Slides
Want to follow Charlie’s presentation step by step?
📊 View the slides:
Ready to See Whether Your CFML Application Runs on BoxLang?
You do not need to rewrite your application first.
You do not even need to decide that you are migrating.
Start with the simpler question:
What happens when we run our existing CFML on BoxLang?
Test the application, measure the compatibility, identify the gaps, and make the decision using your own codebase rather than assumptions.
For many CFML teams, that may be the easiest first step toward discovering what their applications can do next.
Add Your Comment