BoxLang is a modern dynamic JVM language that can be deployed on multiple runtimes: operating system (Windows/Mac/*nix/Embedded), web server, lambda, iOS, android, web assembly, and more. BoxLang combines many features from different programming languages, including Java, CFML, Python, Ruby, Go, and PHP, to provide developers with a modern, functional and expressive syntax.

BoxLang has been designed to be a highly adaptable and dynamic language to take advantage of all the modern features of the JVM and was designed with several goals in mind:

1. Be a rapid application development (RAD) scripting language and middleware.

2. Unstagnate the dynamic language ecosystem in Java.

3. Be dynamic, modular, lightweight, and fast.

4. Be 100% interoperable with Java.

5. Be modern, functional, and fluent (Think mixing CFML, Node, Kotlin, Java, and Clojure)

6. Extend via Modules

7. Be able to support multiple runtime environments:

   1. Native OS Binaries (CLI Tooling, compilers, etc.)

   2. Serverless Computing (AWS Lambda, Azure Functions, etc)

   3. Servlet Containers - CommandBox/Tomcat/Jetty/JBoss/Undertow
8. Compile down to Java ByteCode

9. Framework Capabilities (Scheduling, applications, events, async computing, tasks, queues, modules)

11. Drop-in Replacement for Adobe ColdFusion and Lucee CFML

Launch Video

License

BoxLang is open source and licensed under the License. Copyright and Registered Trademark by Ortus Solutions, Corp.

BoxLang Subscriptions

BoxLang can also be enhanced by to give you:

• Business Support with SLAs

• Enhanced builds

• Custom patches and builds

• Dedicated Engineer

Support Open Source

To support us, please consider becoming our patron at for as little as $10/month.

Discussions & Help

The Ortus Community is how to get help:

You can also join our Slack Box Team at:

Reporting a Bug

We all make mistakes from time to time :) So why not let us know about it and help us out? We also love 😍 pull requests, so please star us and fork us at

Jira Issue Tracking

• BoxLang:

• BoxLang IDE:

• BoxLang Modules:

Resources

• Professional Support:

• GitHub Org:

• Twitter:

• FaceBook:

Ortus Solutions, Corp

This book was written and maintained by and the Development Team.

Ortus Solutions is a company that focuses on building professional open source tools, custom applications and great websites! We're the team behind ColdBox, the de-facto enterprise BoxLang HMVC Platform, TestBox, the BoxLang Testing and Behavior Driven Development (BDD) Framework, ContentBox, a highly modular and scalable Content Management System, CommandBox, the BoxLang <BoxLang> CLI, package manager, etc, and many more -

Versioning Schema

BoxLang is maintained under the Semantic Versioning guidelines as much as possible. Releases will be numbered in the following format:

And constructed with the following guidelines:

• Breaking backward compatibility bumps the major (and resets the minor and patch)

• New additions without breaking backward compatibility bump the minor (and resets the patch)

• Bug fixes and misc changes bump the patch

BoxLang Release & Support Lifecycle

Our release cadence follows a predictable yearly major-version schedule, with each release enjoying two years of Long-Term Support (LTS):

• Active Support: First 12 months after release – full feature updates, bug fixes & security patches.

• LTS (Updates & Security): 2nd year – maintenance releases (minor improvements & security).

• LTS (Security-Only): 3rd year – critical security fixes only, then archived.

This gives you a clear planning horizon and overlap between versions, so you can upgrade on your own schedule without ever being left unprotected.

Support Lifecycle Chart

Here is our 5-year outlook.

• After the “security-only” phase, the version is archived: no further updates, but archives remain available for reference.

• Overlaps ensure there’s always at least one actively maintained release.

• All dates refer to calendar years; exact dates will align with our annual major-version launch each Q1.

Hola amigo! I'm excited that you are interested in contributing to BoxLang. Before submitting your contribution, please make sure to take a moment and read through the following guidelines:

Code Of Conduct

This project is open source, and as such, the maintainers give their free time to build and maintain the source code held within. They make the code freely available in the hope that it will be useful to other developers and/or businesses. Your contributions are crucial in maintaining the integrity of BoxLang. Be considerate towards maintainers when raising issues or presenting pull requests. We all follow the Golden Rule: Do to others as you want them to do to you.

Our official modules can be found in the BoxLang Software Directory: FORGEBOX: www.forgebox.io.

For web runtimes running on CommandBox, our servlet server, then use the box CommandBox CLI for installation and server.json for tracking dependencies. For our operating system runtime, use our install-bx-module binary.

Operating System Modules

Local CLI Application Modules

BoxLang also supports the concept of local loading. Meaning, if you have a boxlang_modules folder in the root of where you run your CLI applications, then BoxLang will load those modules first and then fall back to the user's home directory for the operating system.

CommandBox Runtimes

The CommandBox CLI installs BoxLang modules into web runtimes.

Configuration

You can customize the boxlang module directory by changing the runtime.modulesDirectory setting in your config/boxlang.json file:

Core Modules

Visit the section of our docs for the most up to date listing of our supported modules.

Azure Virtual Machines (Azure VMs) are an Infrastructure as a Service (IaaS) offering for computing, providing more control over your cloud resources. With this service, you can pay as you go or make an annual reservation. However, if you would like more detailed information about this service, you can refer to .

Ubuntu 24.04 LTS based

What is BoxLang?

BoxLang is a modern dynamic JVM language that can be deployed on multiple runtimes, including all operating systems, web servers, Java application servers, AWS lambda, iOS, Android, web assembly, and more.

BoxLang combines many features from different programming languages, including Java, CFML, Python, Ruby, Go, and PHP, to provide developers with a modern, fluent, and expressive syntax. It has been designed to be a highly modular and dynamic language that takes advantage of all the modern features of the JVM.

Goals

• Be dynamic, modular, lightweight and fast

• Be 100% interoperable with Java

• Be modern, functional and fluent

• Modularity at its core

Key Features

1. Dynamic Language: BoxLang is dynamically typed, meaning you don’t need to declare types if you don’t want to. It can do type inference, auto-casting, and promotions between different types. The language adapts itself to its deployed runtime. It can add/remove/modify methods and properties at runtime, making it highly flexible and adaptable.

2. Low Verbosity Syntax: BoxLang is a low-verbosity syntax language. It is highly functional, fluent, and human-readable. Our intent with BoxLang is to make it highly expressive and low ceremony.

3. Scripting: BoxLang can be used for enterprise modular applications and highly reusable and quick scripting on the JVM or Cloud Lambda architectures.

Is it CFML compatible?

BoxLang had been designed with multiple parsers—one for BoxLang and one for CFML. The CFML parser transpiles to BoxLang at runtime or can be translated to BoxLang via our . We try and support as much as we can from CFML. However, we have made very different decisions, and BoxLang is a fresh start for the JVM in a new language. We have introduced a to keep old-school CFML working as it is under the BoxLang runtime.

You will have the choice to continue with CFML-compatible code or come to our new vision with BoxLang. We will support both indefinitely.

Release Video

We launched an open beta of BoxLang at our developer conference,

Welcome to Beta 16! This release focuses on web support functionality and contains a number of improvements and bug fixes for HTTP operations, including multi-part file uploads and error handling. It also provides enhancements to Java interoperability, dump template output, and metadata introspection.

Overall, this beta release brings further stability for CFML applications migrating to BoxLang!

Release notes - BoxLang - 1.0.0-Beta16

New Feature

Implement timeout for HTTP requests

Multi-part request support in HTTP

Improvement

Add text-based toString() method for Queries (used in console dumps)

for in Java transformer not mapping source line numbers for start of loop

Make include case insensitive

Enhance metadata visitor to process extends

add fieldNames key to form scope

Auto casting for URI and URL classes to string

Handle bad gateways in HTTP component

Allow for multiple form fields with the same name in HTTP component

autocast InetSocketAddress to string

Bug

Fix for overeager escaping of quantifier sequences in REFind

High order closures creating incorrect AST when parsing

Update DateTime Parsing to handle the Common Javascript Date.toString format

Module settings no longer overriding after deep merge function added

Java interop doesn't find method by argument types when passing null

Can't assign to List due to incorrect validation in referencer

content-type isn't always getting defaulted in some requests

for/in loop over struct should get String keys instead of BL Key instances

showUDFs not cascading down in dump levels

using cfcookie should update cookie scope

Fix argument order for FileUpload

Setting up BoxLang servers on various cloud platforms involves a series of steps to ensure efficient deployment and management. Below is a brief introduction to setting up BoxLang servers on AWS, Azure, Google Cloud, and IBM Cloud. You can find much more information here: https://boxlang.io/hosting

BoxLang Cloud Servers provide ready-to-use virtual machines optimized for running BoxLang applications. Available on multiple cloud platforms with both Windows and Ubuntu configurations, these solutions streamline deployment and offer seamless scalability for developers and enterprises.

Available Platforms:

• Amazon Web Services (AWS) - Ubuntu & Windows AMIs

• Microsoft Azure - Ubuntu Virtual Machines

• Google Cloud Platform - Coming Soon

Key Features & Advantages

• Pre-configured & optimized - Instantly deploy a fully set-up BoxLang runtime.

• Cloud-ready & scalable - Take full advantage of a powerful infrastructure.

• Enterprise-grade security - Enhanced protection for a reliable environment.

• Cost-effective - Pay only for the resources you actually use.

AWS offers Elastic Compute Cloud (EC2) instances for running BoxLang servers. To deploy:

1. Launch an EC2 instance within your desired region.

2. Choose an appropriate instance type (e.g., t2.micro for low traffic).

3. Configure security groups to allow relevant traffic on required ports (e.g., HTTP, HTTPS).

Azure provides Virtual Machines (VMs) for hosting BoxLang:

1. Create a virtual machine (VM) in the Azure Portal with the required resources.

2. Select a suitable VM size based on your specific needs.

3. Set up network security groups to manage inbound and outbound traffic.

Google Cloud offers Compute Engine virtual machines for BoxLang deployment:

1. Create a VM instance via the Google Cloud Console.

2. Choose machine type and region accordingly.

3. Set firewall rules for your server requests.

Each platform provides comprehensive documentation and support to guide you through specific setup requirements and optimizations.

Welcome to the comprehensive BoxLang tooling ecosystem! This section covers all the tools, IDE integrations, and utilities designed to enhance your BoxLang development experience across different platforms and editors.

🚀 Official IDE Support

BoxLang provides first-class support for modern development environments with our official Visual Studio Code extension, compatible across multiple editors and platforms.

BoxLang Beta 25 Has Landed!

This release takes BoxLang to the next level, delivering a mix of critical bug fixes, thoughtful improvements, and exciting new features designed to enhance your development experience. With Beta25, we’ve solidified and made the ASM ByteCode BoxPiler the default compiler, refined module, and logging management, and added long-requested query of queries and JSON-based logging encoders. Additionally, we’ve tackled critical issues around debugging, compatibility, and system settings to make this the most stable and feature-complete beta yet.

At this point, we have a handful of small bugs open, which will completely certify all of the major Ortus frameworks like ColdBox, ContentBox, and over 50 modules. Complete certification is around the corner.

As a bonus, we are almost ready to release our Hibernate ORM module (bx-orm) and move into a Release Candidate phase for our entire lineup. So please test test test, and give us your feedback.

✨ New Features

• : createObject() now supports classloading arguments as the third argument.

Easily manage and control classloading with arguments to enhance flexibility and modularity.

• : Dynamic Task Management in Schedulers

Added startupTask(task) to dynamically initialize tasks by name or task object.

• : JSON-based Logging Support

Appenders and root configurations now include JSON encoders for enhanced logging formats.

• : Improved Scheduler Logging

Scheduler logs are now effectively reported to provide better insights.

• : Enhanced Module Logging

Modules now have dedicated logs to improve debugging and diagnostics.

• : New Event Lifecycle: onConfigurationLoad

Introduced a new lifecycle event for IServices to optimize configuration handling.

• : Enhanced Compatibility Assignments

Assignments now accurately interpret null variables for better compatibility.

• : New Logging Setting: statusPrinterOnLoad

Added statusPrinterOnLoad for much-needed debugging of logging configurations.

🛠 Improvements

• : Streamlined Method Expectations

Improved handling of methods that don’t expect return values for better consistency.

• : Enhanced Session Cookie Controls

Added missing controls for session cookie management to improve security and compliance.

• : Bytecode Line Number Enhancements

Added line number details to bytecode generated with ASM for improved debugging.

• : ASM is Now the Default BoxPiler

Streamlined the toolchain by making ASM the only default stock BoxPiler.

• : Optimized Replace Operations

Updated replaceAll() methods to use pre-compiled patterns for better performance.

• : Unified Logging Configuration

Consolidated logging startups and configurations for both servlet and non-servlet environments.

• : Support for this.componentPaths

Introduced implicit mapping support for more intuitive path management.

• : Module Enable/Disable Support

Modules can now be enabled or disabled using enabled in boxlang.json, removing double negatives like disabled.

• : Forms Module Introduced

A new module for handling forms was added, enhancing the BoxLang ecosystem.

• : Improved Scope Assignment

Allowed reassignment of a scope to a struct for more flexible programming.

• : Collision Prevention in IClassRunnable Methods

Prefixed methods to prevent naming collisions for safer execution.

• : Graceful Module Unloading

Added defensive coding for module unloading failures to ensure runtime stability.

• : Consistent Struct Collector Outputs

Resolved inconsistencies by ensuring collectors return Struct objects.

• : Improved Parent Class Delegation

Enhanced module class loaders to delegate certain parent classes to the parent loader exclusively.

🐞 Bug Fixes

• ASM and Debugging Fixes:

, , , ,

• Localization and Formatting Issues:

, ,

• Parsing Errors:

, ,

• Thread and Scope Resolution Bugs:

, ,

• Miscellaneous:

, , ,

This release brings enhanced XML handling, new CLI app support, improved error handling, and expanded interoperability with Java and CFML runtimes. We've also added new HTTP event hooks, improved caching strategies, and a streamlined class resolution process to make your applications more performant, even in debug modes.

🌟 Highlights:

✅ Enhanced XML Support – Improved cloning, merging, and namespace handling in XML operations. ✅ Unified Template & Script Grammars – BoxLang now seamlessly integrates both styles, bringing performance updates to the parser. ✅ Improved Java Interop – Automatic coercion of BoxLang arrays to native Java arrays and varargs support ✅ Better Error Handling – More robust dump rendering and exception management. ✅ New CLI Features – Built-in functions like cliRead(), cliGetArgs(), and cliExit() for pure CLI apps. ✅ Improved HTTP Handling – Proxy support, authentication, and new request/response events.

✅ Trusted Cache – Trusted cache is in the house, to get high performance in production

✅ Class location caches – More performance updates for class resolutions for BoxLang classes

With over 40 improvements, new features, and fixes, this release makes BoxLang even more powerful and stable! 🔥

Improvements

Implement Node pass-through methods to handle cloning and merging of XML objects

Combine template and script grammars for boxlang

Error Getting method keyExists for class ortus.boxlang.runtime.types.XML

StructFindKey returns two findings on the same node if top level key is array

Better error handling when dump template errors

Return callback return value from runThreadInContext()

java interop coerce BL arrays to native arrays

Add toOptional() method to Attempt

coerce return values of proxied methods

output class of non-simple valued fields in class output for cfdump

prefer same mapping for relative class lookups in box resolver

Client scope needs more consistencies like the session scope when validating and expiration determination

Module service record was not registering interceptors with the module settings

HTTP Component - Implement Proxy Server handling

add default itnerface helper for the IBoxContext to get the running application name if any

Servlet to support Jakarta namespace

New Features

Move defaultCache to the caches section as default, verify it exists, else create it anyways

add http events: onHTTPRequest, onHTTPResponse

Expose buildRegistry() and encapsulate per location registration

CLI BIFS for working with pure cli apps: cliRead(), cliGetArgs(), cliExit()

Activate box resolvers cache according to request and app settings

New setting: classResolverCache : boolean [true] which controls if the class locators caches resolve lookups

Bugs

varargs not working

CF casts Class instances to a String

Namespaced XML nodes not accessible by their non-namespaced names

XMLSearch Not Finding Correct Results When Namespaces are Present

XML asString Generates trailing line break

StructFindKey Not Returning owner values correctly

ASM compilation error

query with empty column name can't be dumped

WriteDump()/Dump() is broken in current snapshot build

DateCompare on two zero-hour strings fails with long overflow

XMLElemNew Illegal Character exception when using the namespace URI as the second argument

HTTP Component - Implement Basic Authentication

Cannot access variables scope in a static context -- but there is no variables access

timezone not always used in datetime caster

toUnmodifiableStruct() method not threadsafe

directoryList filter param does not accept a closure

Support for guid and uuid type

getDirectoryFromPath returns different result to Lucee and ACF

argument type of binary is not supported

argument type of email is not supported

CGI scope reporting 0 items

JSONSerialize pretty prints JSON which blows up outbound NDJSON

CFHTTParam Encodes Query Strings By Default

URLEncodedFormat Replaces Spaces with Plus Symbols

Bracket Notation Usage on Java Hashmaps Does not work.

Detail and Extended Info Can Be Null In Thrown Exceptions

Clean, modern themes designed specifically for BoxLang development. This extension provides two carefully crafted color schemes that enhance your BoxLang coding experience with optimal syntax highlighting and visual appeal.

🎨 Available Themes

BoxLang Dark (Neon)

High-contrast dark theme featuring vibrant neon colors with pink, purple, and cyan accents. Optimized for extended coding sessions while maintaining visual appeal and code readability.

BoxLang Light (Muted)

Subtle light theme with soft teal and green backgrounds, perfect for daytime development. Features muted accent colors that reduce eye strain during long coding sessions.

✨ Key Features

• BoxLang Optimized - Specifically designed for BoxLang syntax highlighting and component recognition

• Semantic Highlighting - Enhanced token colors for better code understanding

• Bracket Pair Colorization - Distinct colors for matching brackets and parentheses

• Complete UI Theming - Consistent colors across editor, sidebar, terminal, and all VS Code interfaces

📦 BoxLang Developer Pack

The BoxLang Developer Pack is a curated extension pack that includes everything you need for BoxLang development:

• 🚀 BoxLang Language Support - Complete language server with IntelliSense, syntax highlighting, and error detection

• 🎨 BoxLang Theme - This theme extension with both Dark (Neon) and Light (Muted) variants

• 🧪 TestBox Support - Full TDD/BDD testing framework integration

• 📦 CommandBox Integration - Package management and project scaffolding tools

Install the Complete Pack

Instead of installing extensions individually, get the full BoxLang development environment:

VS Code Marketplace:

OpenVSX Registry:

This automatically installs all BoxLang development tools, including this theme, saving you time and ensuring a complete setup.

📦 Individual Installation

VS Code Marketplace

Install from the :

1. Open VS Code and go to Extensions (Ctrl+Shift+X / Cmd+Shift+X)

2. Search for "BoxLang Theme"

3. Click Install

4. Go to File → Preferences → Color Theme

OpenVSX Registry

For VS Code compatible editors like Cursor, Windsurf, VSCodium, install from .

Command Line Installation

🎯 Recommended Settings

Enable these VS Code settings for the best theme experience:

🔧 Theme Selection

After installation, activate your preferred theme:

1. Windows/Linux: Ctrl+K, Ctrl+T or File → Preferences → Color Theme

2. macOS: Cmd+K, Cmd+T or Code → Preferences → Color Theme

🛠️ Development & Contributing

GitHub Repository

• Source Code:

• Report Issues:

Contributing Guidelines

1. Fork the repository

2. Create a feature branch

3. Edit theme JSON files in the themes/ directory

4. Run npm run build to validate changes

Beta 4 is a small incremental release which includes improvements and bug fixes.

Improvements

BL-299, BL-300, BL-301, BL-302 Query caching improvements and compatibility updates

BL-315 Ensure request attributes are available to the web runtime scope

BL-164 bx-compat-cfml CFML compatibility module updates to ensure null query column values are returned as empty strings

Bug Fixes

Fixes compilation issue with variables name cfcatch

CFML compatiblity for CGI.QUERY_STRING when not provided

Fix null queryparam functionality

The BoxLang 1.0.0-Beta22 release includes several improvements, bug fixes, new features, and stories. Key improvements include enhanced redirection for the Miniserver, better transactional event broadcasting, and added convenience methods like getRequestContext() and getApplicationContext(). Bug fixes address issues such as JSON deserialization, whitespace management, and various errors related to data types and loops. New features include support for multiple statements inside queries and a new datasourceRegister() BIF for easier SaaS integrations.

Release Notes

Google Virtual Machines are an Infrastructure as a Service (IaaS) offering for computing, providing more control over your cloud resources. With this service, you can pay as you go or make an annual reservation. However, if you would like more detailed information about this service, you can refer to .

Ubuntu 24.04 LTS based

CommandBox amalgamates many tools and borrows concepts from NPM, Grunt/Gulp, Maven, ANT, Node, and more. Features include:

• Operation System integration for executing commands

• Ability to create and execute commands built using BoxLang and CFML

• ForgeBox integration for cloud package management and installations

Bugs

BoxRunner fails on some input args

BoxLang is an innovative language designed to seamlessly substitute Adobe ColdFusion and Lucee in your existing projects. It offers robust functionality, ensuring compatibility with your current systems while providing enhanced performance, modern features and cheaper.

With its straightforward syntax and comprehensive toolset, BoxLang empowers developers to maintain and upgrade their applications with minimal hassle. Whether you're starting a new project or migrating an existing one, BoxLang serves as a reliable and efficient choice for modern web development needs.

Follow our migration guides below in order to migrate your existing ColdFusion/Lucee applications to a BoxLang runtime.

Migration Guides

Interested in playing with BoxLang? You can test the syntax in a BoxLang interpreter hosted on AWS Lambda over at try.boxlang.io. These two micro-services have been written with BoxLang as well.

SyntaxHighlighter

BoxLang brush module for SyntaxHighlighter. Please check out the instructions on how to build your own SyntaxHighligther and add custom brushes.

Installation

Example

We have really kicked into gear with this release, tackling a whopping 26 tickets and delivering some of our most aggressive features to date. This update signifies a significant leap forward towards a stable release in the Fall. Thank you for your continued support and stay tuned for more exciting developments!

New Features

BoxLang has been designed with a lightweight, fast, and modular core. The operating system binary is a whopping 8MB in size. This allows us to build on this binary according to the deployed runtime of choice. Check out our

Available Runtimes

The currently available and in-development runtimes are the following:

In this release, we've introduced the exciting addition of websockets support to BoxLang through the powerful module. This enhancement is not limited to our Runtime but also extends to our runtime, creating a more dynamic and efficient framework for real-time communication. For an in-depth introduction to these features, please visit our community post .

Additionally, we've implemented several new features and improvements. We've also improved the system startup process by adding version and build date information to the MiniServer startup output (). Lastly, we've addressed session management by ensuring that application settings are readily accessible during the onSessionEnd event (). This release encapsulates our ongoing commitment to providing robust, cutting-edge solutions for developers and reaching stable release in the coming weeks.

This release introduces several new features and configurations to enhance functionality and security. It also continues to squash tons of bugs to bring about CFML compatibility. Key updates include:

• Enhanced arrayFind and arrayFindNoCase functions, allowing value closures to accept item indices.

• New validBoxLangTemplates configuration for filtering templates processable by the Runnable Loader.

One convenient feature of our official BoxLang VS Code extension is the . The MiniServer is just that, a web server built to be fast and easy to work with. You can use it to spin up a server in any directory within your project and almost instantly test code. We even save your configuration to reuse your server again in the future! Let’s take a quick look at how to configure the MiniServer and some of its features.

The MiniServer Panel

After installing the BoxLang extension, you should see a new icon featuring the BoxLang logo in the sidebar. Clicking this icon brings up the BoxLang Server Panel. Here you will see a list of the servers you are currently using for the workspace you are currently in. To start configuring a server click the “+” icon at the top right-hand corner.

The source code for this book is hosted on GitHub: . You can freely contribute to it and submit pull requests. Ortus Solutions, Corp copyrights the contents of this book and cannot be altered or reproduced without the author's consent. All content is provided "As-Is" and can be freely distributed.‌

Notice of Liability

‌The information in this book is distributed as is, without warranty. The author and Ortus Solutions, Corp shall not have any liability to any person or entity concerning loss or damage caused or alleged to be caused directly or indirectly by the content of this training book, software, and resources described in it.

New Features

• - Zip Components, Utility and incorporating BIFS

• - Implement pagePoolClear()

You can find a collection of frequently asked questions in our main website here:

This block is used to have experimental feature flags for BoxLang. Every experimental flag will be documented here once we have them.

Compiler

This is the compiler used for your BoxLang source. The available options are:

• java : We will transpile your BoxLang source to Java, then compile it

BoxLang is a modular language. Each module can have a configuration structure for usage within the language. The name of the key is the name of the module and each module config has the following keys available:

• enabled : Boolean indicator to disable or eanble the module from loading. Defaults to `true`

• settings : A structure of configuration settings each module exposes

/**
 * The BoxLang module settings
 * The key is the module name and the value is a struct of settings for that specific module
 * The `enabled` property is a boolean that determines if the module should be enabled or not
 * The `settings` property is a struct of settings that are specific to the module and will be override the module settings
 */
"modules": {
    // The Compat Module
    "compat-cfml": {
        "settings": {
            "engine" : "Adobe"
        }
    },
    // The Mail module
    "mail" : {
        "settings" : {
            "spoolEnable" : true,
            // Spool interval, in minutes
            "spoolInterval" : 1.5,
            "mailServers" : [
                {
                    "tls": false,
                    "password": "",
                    "idleTimeout": "10000",
                    "lifeTimeout": "60000",
                    "port": "25",
                    "username": "",
                    "ssl": false,
                    "smtp": "127.0.0.1"
                }
            ]
        }
    }
}

BoxLang Betas are released weekly. This is our eigth beta marker and we are excited to report that we are 100% tag compatible with Adobe/Lucee and 99% BIF compatible. We can estimate that in the next 2 betas we will be 100% compatible with both Adobe/Lucee CFML engines when running BoxLang in compatibility mode.

New Features

contractPath() BIF

This allows you to get a relative path or mapping path from a fully expanded path in your system. This is useful, to understand where a full absolute path comes from:

Add loop times=n

We have added a new construct for looping by using the keyword times in your loop statements:

You can also use times and the index

Or the item alias can be used as well as the index

Implement GetBaseTagList() and getBaseTagData()

These two methods are to bring us closer to finalizing the creation of custom templating language constructs.

• getBaseTagList( [caller] ) : Gets a comma-delimited list of uppercase ancestor tag names, as a string. The first list element is the current tag. If the current tag is nested, the next element is the parent tag. If the function is called for a top-level tag, it returns an empty string.

• getBaseTagData( tagName, [level=1] ) : Used within a custom tag. Finds calling (ancestor) tag by name and accesses its data.

Improve parser error messages for unpopped parser modes

For code like

or

instead of our default “unpopped modes”, detect what specific mode is on the stack (comment_mode, quotesMode, etc), find the start token (comment_start, OPEN_QUOTE, etc) and report the line number that the unclosed construct started, which could be hundreds of lines from the end of the file when parsing finally stopped.

Transaction events

The BoxLang JDBC Transactions framework is now complete and incredibly robust. More than the other CFML engines or even Spring-based transaction demarcations. It is fully documented here:

We have also added several events that you can listen to during the transaction processes:

• onTransactionBegin

• onTransactionEnd

• onTransactionCommit

Note that all these events (with the exception of onTransactionAcquire and onTransactionRelease) have the potential to be acting upon a no-op transaction, with a null connection parameter since no connection was ever obtained.

Improvements

Allow for circular references in structs and arrays

Java 21 update to URL creation as new URL is deprecated

add getMimeType method in FileSystemUtil to make it easier to get mime types of remote files ( e.g. PDF creation )

Bugs

<bx:loop query="query"> doesn't iterate over each item in the query, stays on the first item

session scope can be null in onSessionEnd, causing errors

Tasks

Create tests for all valid and invalid dot and array access expressions

This release introduces several new features aimed at enhancing the usability and functionality of BoxLang. We have closed a tremendous amounts of bugs on this release in order to bring more compatibility and stability to BoxLang. We have also started to introduce performance enhancements and more innovations as we progress towards final release.

Enjoy!

New Features

Writedump output support

We have finalized the console output for the dump component, but we have also added the following ticket:

New dump event to listen when an non-core output is detected so modules can handle it. onMissingDumpOutput

Which will allow module developers to collaborate their own output destinations for any dump in the language. This is something we have wanted for years and it's now a possibility. Just listen to the onMissingDumpOutput interception point, you get all the arguments to the BIF or component and you decide where things will go. VScode Dump Panel, here we come.

The console output has also been enhanced where everything will be pretty printed, including labels.

Ability to mark a @BoxBif as excluded from documentation

This is more of an internal documentation process for the team.

New dump template for Java instants

Java Instants will now be dumped nicely with an internal representation and a human readable representation.

dump showUDFs

All the arguments for dumps are now available including this one for controlling the dumping of UDFs on classes.

Improvements

Simplify BoxLang class dumps

Add output and format to dump

Some BIFs not fully supporting BigDecimal values

access e.cause as shortcut for e.getCause()

When creating an abstract class a new `AbstractClassException` is thrown. Great for testing frameworks

Bugs

queryaddcolumn ignores the datatype

Issue with #dateTimeFormat(now(),'mm-dd-yyyy')# function returning incorrect results

structnew( "linked" ) doesn't work

argumentCollection doesn't work with implicit constructor

directory component must always return query

BoxNewTransformer using hard-coded context name

toNumeric() not accepting radix values of 2-36

cannot cast [x to object] on generic caster when using `QuerySetCell()`

Issue with `Duplicate()` Function Causing Null Pointer Exception in BoxLang

final keyword not working on this scope

directoryList() filters are not working as closures/lambdas as they are hardcoded as strings

Cannot invoke "ortus.boxlang.runtime.types.Query.isEmpty()" because "this.query" is null

Multiple pipe-delimited glob patterns are not working as directoryList filters

DuplicationUtil not doing deep clones of structs according to all types

Throwing custom type exceptions just shows `custom` as the type instead of the actual type in the throw

remote access not treated as public but as private for functions

Interfaces don't support multiple inheritance

CFC source type not detected correctly for abstract or final classes

Metadata with : in them in cfml mode not treated correctly

xml entity parsing issue when calling `toString()` on Java objects

🚀 Introducing BoxLang 1.0.0 Beta 20! 🚀

This release brings another round of powerful tools and refinements to the BoxLang community, making development more dynamic and robust than ever. We’ve added new capabilities for debugging and tracing, expanded context-sensitive controls for thread management, and introduced new methods for fluent attachment handling.

For deeper flexibility, our improvements enhance configurability, streamline session control, and add deeper levels of JSON serialization management. Plus, we’ve squashed a wide range of bugs, enhancing stability across database connections, date handling, and runtime compatibility with CFML.

New Feature

trace bif and component

Setup the thread's context class loader when an application is defined with the correct loader from the Applications java settings

showDebugOuput added to request box context to allow for tracer/debugging outputs

new computeAttachmentIfAbsent, to make fluent attachments on IBoxAttachable implementations

refactor escapeHTML to the lib we use instead of multiple functions

DateTime objects don't have a len member method

Improvements

Add line break in dump console output

Allow access to super scope from thread

reuse config of validTemplateExtensions

Add ability to deep merge config items from the environment.

track current request context in thread

improve concurrency of session ID creation

Move from immutable verbiage to unmodifiable

Need to set explicit `/` path on session cookies

if calling serializeJSON() on a class, and the class is marked as not serializable, then return empty struct

if calling serializeJSON() on a class, properties marked as not serialiable should be skipped.

Arrays/Lists/Structs/Maps/Classes that have been visited already by JSON will not serialize again but show a recursion marker

Bugs

bx-compat-cfml datediff fails to convert string

Update parser to allow for `@module` notations on imports and `new` operators

NOT operator precedence not grabbing operators in the chain

Java Doc implementation is stricter that ACF and Lucee

Missed module class hierarchy to have the runtime class loader as the parent

ortus.boxlang.runtime.events.InterceptorPool: Errors announcing [logMessage] interception ortus.boxlang.runtime.types.exceptions.BoxRuntimeException: An error occurred while attempting to log the message

Dump not showing BoxLang type NullValue as null

DBInfo schema and several other columns can be null, make sure you address it

boxclass dump looping construct exception

java class method not found

argument collection optional param is null

Cannot convert class ortus.boxlang.runtime.types.DateTime to SQL type requested due to com.mysql.cj.exceptions.WrongArgumentException - Conversion from ortus.boxlang.runtime.types.DateTime to TIMESTAMP is not supported.

DatabaseException: There is no known date-time pattern for '09/24/2024' value at ortus.boxlang.runtime.jdbc.PendingQuery.executeStatement(PendingQuery.java:390)

cannot get lenght of native java date time objects

Can't cast [2021-01-01 12:00:00 pm] to a DateTime.

Dynamic Language

BoxLang, a compiled programming language, operates in a unique way. It doesn’t run directly on your processor but is instead processed by a middleman known as the Java Virtual Machine. This processing occurs in the form of Java Bytecode, a low-level representation of your BoxLang code. This approach, coupled with BoxLang's dynamic nature, frees you from the typed restrictions of compile-time languages like Java, offering a more flexible programming experience.

This means you have greater flexibility as the engine infers your types. It allows you to do runtime manipulations like method injections, removals, metadata programming, etc., that a typical typed language would not allow. It also allows us to escape the dreaded compile, build, deploy cycle since the BoxLang scripts will be evaluated, compiled, and executed all at runtime. This means no more re-deploying or annoying restarts, saving you valuable time and effort.

ByteCode

BoxLang compiles to Java Byte code using two provided algorithms.

Debug JIT Algorithm

Production JIT Algorithm

Code - Execute - Refresh - Repeat

BoxLang is a dynamic language that allows you to do just-in-time compilation, so you don't have to compile, build, and deploy.

Code Portability

BoxLang will convert your code into byte code and feed it into the Virtual Machine (VM) to execute it. This approach benefits you by allowing you to write BoxLang code once and, typically, execute it on many different operating systems and hardware platforms. Then, you can use our multi-runtime approach and deploy to multiple runtimes.

Java Interop

BoxLang is 100% interoperable with Java since it runs on the JVM. It allows you to use all third-party Java libraries, import classes, extend, implement scripting, and much more.

JSR-223

BoxLang is a certified that can be used by any JVM language via the Scripting API.

Multi-Runtime

BoxLang has been designed to run in many using our multi-runtime approach. You can run BoxLang in any OS, web server, servlet container, docker engine, AWS Lambda, and more coming soon.

Running from the Command Line

This is a durable way to write BoxLang code because you save your instructions into a file. That file can then be backed up, transferred, added to source control, etc.

An Example Scripting File

We might create a file named hello.bxs like this:

Then we could run the program like this boxlang hello.bxs and get the following result:

BoxLang REPL

BoxLang ships with a memory REPL (Read Eval Print Loop) interface that you can use to test out the language. Just run the boxlang binary, and you are ready to roll:

Keep reading our guides as you learn more about BoxLang.

BoxLang includes a powerful built-in task scheduler that allows you to schedule and manage tasks at the runtime level. The scheduler is managed by the SchedulerService and can be configured globally or programmatically.

Configuration Structure

The scheduler configuration is located in the scheduler section of your boxlang.json file:

Configuration Properties

executor

Type: string Default: "scheduled-tasks" Description: The name of the executor to use for running scheduled tasks. This must reference a valid executor defined in the executors section.

cacheName

Type: string Default: "default" Description: The cache to leverage for server fixation or distribution. This is useful when running BoxLang in clustered environments to coordinate scheduled tasks across multiple instances.

schedulers

Type: array Default: [] Description: An array of absolute paths to BoxLang scheduler files (.bx) that should be registered upon runtime startup. You can use variable substitutions like ${user-dir} or ${boxlang-home}.

tasks

Coming soon.

Type: object Default: {} Description: You can define tasks manually in the configuration instead of using scheduler files. Each task is defined as a key-value pair where the key is the unique task name.

Programmatic Scheduling

You can also create and manage scheduled tasks programmatically using BoxLang's scheduling functions and components. The configuration above provides the foundation and default settings for the scheduler service.

Related Configuration

• - Configure the thread pools used by the scheduler

• - Configure caches used for task coordination

• - Configure logging for scheduler operations

is a standalone, native tool for Windows, Mac, and Linux that provides a Command-Line Interface (CLI) for developer productivity, tool interaction, package management, embedded JEE server, application scaffolding, and sweet ASCII art. CommandBox is the defacto enterprise servlet deployment platform for BoxLang, providing production-ready capabilities for mission-critical applications.

CommandBox seamlessly integrates to work with any of *Box products, but it is also open to extensibility for any BoxLang or CFML project. We have created a specialized servlet runtime for CommandBox that makes it the premier choice for deploying enterprise BoxLang applications with high-traffic and mission-critical requirements.

🚀 Enterprise Features & BoxLang Subscriptions

BoxLang has an installation-level configuration file that allows developers to adjust various settings from the compiler to default cache providers, runtime-wide data sources, and much more. Depending on which runtime you are using, the configuration file location might change, but the configuration segments remain the same.

This segment is where you can configure the security elements of BoxLang under the securityblock in the boxlang.json

Allowed File Operation Extensions

An explicit whitelist of file extensions that are allowed to be uploaded - overrides any values in the disallowedWriteExtensions

Individual file extensions may be whitelisted in your Application context like so:

Welcome to Beta 15! This release brings several significant enhancements aimed at improving the efficiency and functionality of the CLI environment and continued bug fixing to bring our CFML compatibility to several client applications and Ortus Libraries. Key among these is the introduction of the bx-web-support module, which allows the CLI to interface with web server capabilities, making it an excellent tool for testing and feature auditing. Additionally, the merge capabilities within module settings have been refined to support deep merges from the configuration file, ensuring greater flexibility and control.

Moreover, running scripts or classes via CLI execution now supports the automatic detection and execution of Application.bx|cfc, streamlining the process for developers. The new ToString dump template enhances debugging by enabling a concise display format for lists of Java objects, simplifying the analysis and debugging process.

Overall, this beta release brings further stability for CFML applications migrating to BoxLang!

This release brings another round of powerful tools and refinements to the BoxLang community, making development more dynamic and robust than ever. We’ve added new capabilities for debugging and tracing, expanded context-sensitive controls for thread management, and introduced new methods for fluent attachment handling.

For deeper flexibility, our improvements enhance configurability, streamline session control, and add deeper levels of JSON serialization management. Plus, we’ve squashed a wide range of bugs, enhancing stability across database connections, date handling, and runtime compatibility with CFML.

In addition, CSRF Token functionality is now provided via .

New Feature

Global events for Application events

Azure Virtual Machines (Azure VMs) are an Infrastructure as a Service (IaaS) offering for computing, providing more control over your cloud resources. With this service, you can pay as you go or make an annual reservation. However, if you would like more detailed information about this service, you can refer to .

Ubuntu 24.04 LTS based

So you’ve installed and are running the latest BoxLang server like a boss. You open up your browser and are met with an error message. This looks like a job for, you guessed it, the BoxLang VS Code Debugger!

Hooking VS Code Up To Your Server

Connecting your debugger to an external may seem intimidating but CommandBox + VS Code makes this pretty straightforward.

BoxLang ships with many CLI tools. The BoxLang Compiler is one of them. This tool allows you to compile a file or a directory of files into Java Bytecode. This will allow you to do sourceless deployments.

This tool will compile and place (by default) your BoxLang files into Java bytecode so you can do sourceless deployments. When BoxLang goes to compile a file, it will check to see if the file has bytecode in it and proceed with loading the class directly, skipping the parsing and compilation step.

Luis Fernando Majano Lainez

Luis Majano is a Computer Engineer who has been developing and designing software systems since 2000. During economic instability and civil war, he was born in San Salvador, El Salvador, in the late 70s. He lived in El Salvador until 1995 and then moved to Miami, Florida, where he completed his Bachelor of Science in Computer Engineering at .

He is the CEO of , a consulting firm specializing in web development, BoxLang, Java development, and open-source professional services. He is the creator of ColdBox, ContentBox, CommandBox, WireBox, TestBox, LogBox, and anything "Box," and he contributes to over 250 open-source projects. He has a passion for learning and mentoring developers so they can succeed with sustainable software practices and the usage and development of open-source software. You can read his blog at

Datasources

Here is where you can register datasources globally in the runtime. You can override them at runtime via:

• Application.bx|cfc - For the application

Introducing BoxLang 1.0.0 Beta 23

The latest release of BoxLang, Beta 23, marks a significant step forward in our journey to create the ultimate dynamic language for the JVM. Packed with powerful new features, important bug fixes, and thoughtful optimizations, this update is designed to make your development experience smoother, faster, and more reliable, especially after now starting to take 100s of comments and bug reports from our community.

Modularity takes center stage in this release with the ability to define BoxLang components (aka Tags) within modules and a new version-checking mechanism that ensures module compatibility. Database interactions are now more intuitive with enhancements to the Generic JDBC Driver, and the introduction of the getSemver() function brings a robust tool for managing semantic versioning with precision and ease.

🚀 BoxLang Release Candidate 1 is Here! 🚀

After nearly a year of relentless iteration, rigorous testing, blood, sweat, lots of praying, tears, and over 1,000 resolved tickets, we proudly announce the first Release Candidate (RC1) of BoxLang! With 27 beta versions behind us, we are now on the final stretch toward the official 1.0 release.

This milestone ensures that most of our libraries are fully compatible and certified for BoxLang, making it production-ready. RC1 delivers significant bug fixes, performance optimizations, and stability enhancements, enabling teams to deploy and fine-tune their applications in real-world environments confidently. We strongly encourage the community to start running production workloads now—your feedback will be instrumental in refining BoxLang ahead of the final release.

What is a Debugger?

Have you used a debugger before? Have you used one regularly? If you have great! Hopefully, BoxLang’s debugger will make you feel at home. Let me introduce the concept if you are unfamiliar with using a debugger as part of your development process.

Debuggers are a program that runs and controls the execution of the software you are developing. As the debugger is in control of the execution of every instruction, it can freeze the program and provide the developer a chance to inspect the state of their software as if they could freeze time. Often, debuggers will give the developer the power to inspect and change variables within their program and move execution back and forth.

Discover an extensive collection of demos at . This repository offers a wide range of example projects and code snippets designed to illustrate various programming concepts, techniques, and real-world applications.

Whether you are a beginner looking to learn new skills or an experienced developer seeking advanced implementations, this resource provides valuable insights and practical demonstrations to help you enhance your understanding and expertise.

🚀 Demo Categories

The demo repository contains examples across multiple categories:

BoxLang allows you to register named executors globally. The JSON object key is the name of the executor and the value is another object with the type and a threads property, which is optional. By default, BoxLang pre-configures two executors for you: