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

   4. Docker Containers

   5. Android/iOS Devices

   6. Web assembly

   7. Etc

8. Compile down to Java ByteCode

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

10. Professional Open-Source Support

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

Launch Video

License

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

BoxLang Subscriptions

BoxLang can also be enhanced by purchasing subscriptions to give you:

• Business Support with SLAs

• Enhanced builds

• Custom patches and builds

• Dedicated Engineer

• Premium Modules

• Much More...

Support Open Source

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

Discussions & Help

The Ortus Community is how to get help: https://community.ortussolutions.com/c/boxlang/42

You can also join our Slack Box Team at: https://boxteam.ortussolutions.com

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 https://github.com/ortus-boxlang/boxlang

Jira Issue Tracking

• BoxLang: https://ortussolutions.atlassian.net/browse/BL

• BoxLang IDE: https://ortussolutions.atlassian.net/browse/BLIDE

• BoxLang Modules: https://ortussolutions.atlassian.net/browse/BLMODULES

Resources

• Professional Support: https://www.ortussolutions.com/services/support

• GitHub Org: https://github.com/ortus-boxlang

• Twitter: https://x.com/TryBoxLang

• FaceBook: https://www.facebook.com/tryboxlang/

• LinkedIn: https://www.linkedin.com/company/tryboxlang

Ortus Solutions, Corp

This book was written and maintained by Luis Majano and the Ortus Solutions 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 - https://www.ortussolutions.com/

Bugs

BoxRunner fails on some input args

New Features

• - Zip Components, Utility and incorporating BIFS

• - Implement pagePoolClear()

• - Add the ability to configure the CF transpiler

• - Transpiler doesn't handle attributeCollection

• - Zip Components, Utility and incorporating BIFS

Improvements

• - Compiler thread safety

• - Implements SystemCacheClear()

• - Allow "object" passed to throw to be a struct representation of an exception

• - Added all missing boxlang types to BoxLangType class

• - Address parser performance by limiting operator reserved words

• - Change template parsers to use SLL prediction mode

• - Improve parsing performance by only calculating lines of code on error

• - Add ValueRequiresOneOf Validator

Bugs

• - Lock expects timeout to be minimum of 1

• - numeric literals with leading zeros are confused with octal values in java source

• - getApplicationMetadata() fails before application listener is defined

• - AST string values incorrectly unescaped outside of cfoutput

• - Pretty printer incorrect for default case ending tag

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

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 the bx-csrf module.

New Feature

BL-713 Global events for Application events

BL-720 Implement table filter for dbinfo component

BL-721 getComponentList() should also return the declared attributes of a component

BL-722 getFunctionList() should also return the declared arguments of a BIF

Improvement

BL-710 Implement Algorithm Argument for RandRange

BL-716 Set request class loader into thread as context class loader

BL-717 Retain directories in dynamic class loader

BL-728 Add nullIsUndefined flag to control how null variables are handled

BL-729 Don't default properties with no default value to null when compat has enabled nullIsUndefined scope behavior

Bug

BL-638 Passing a null named argument hides outer bindings by the same name

BL-641 Missing BIF - CSRFGenerateToken is now supplied with the bx-csrf module

BL-669 Difference in args vs local variables handling

BL-677 Incompat: metadata annotations from inherited sub classses added to top level class

BL-679 cfloop collection with an array throws casting exception

BL-697 argument collection optional param is null

BL-711 dot access not chaining to static access

BL-712 NPE when calling non-existent Java method

BL-715 Duplicate of cfc instance presenting as struct

BL-718 Key access in StructMapWrapper not working

BL-719 GetTagData(), GetFunctionData() function not implemented, implement in the COMPAT module

BL-724 import name restrictions too strict

BL-726 Assignment not working on static fields of an imported class

BL-727 Adding two ints uneccessarily returns a long

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

BL-305 Fixes compilation issue with variables name cfcatch

BL-309 CFML compatiblity for CGI.QUERY_STRING when not provided

BL-314 Fix null queryparam functionality

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

# Install os-wide modules
install-bx-module bx-compat-cfml

# Install os-wide modules with a specific version
install-bx-module [email protected]

# Install multiple modules
install-bx-module bx-compat-cfml bx-esapi bx-orm

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.

# Install locally
install-bx-module bx-compat-cfml --local

# Install locally
install-bx-module [email protected] --local

# Install multiple modules locally
install-bx-module bx-compat-cfml bx-esapi bx-orm --local

CommandBox Runtimes

The CommandBox CLI installs BoxLang modules into web runtimes.

box install bx-compat-cfml bx-esapi

Configuration

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

{

    // A collection of BoxLang module directories, they must be absolute paths
    "modulesDirectory": [
      "${boxlang-home}/modules"
    ],

}

Core Modules

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

In this release, we've introduced the exciting addition of websockets support to BoxLang through the powerful SocketBox module. This enhancement is not limited to our CommandBox Runtime but also extends to our MiniServer 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 here.

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 (BL-607). Lastly, we've addressed session management by ensuring that application settings are readily accessible during the onSessionEnd event (BL-610). This release encapsulates our ongoing commitment to providing robust, cutting-edge solutions for developers and reaching stable release in the coming weeks.

New Features

BL-605 MiniServer WebSocket handler

Improvement

BL-607 Add version/build date to output of Miniserver startup

BL-610 onSessionEnd needs application settings made available

BL-611 Remove debugmode capture on miniserver, delegate to the core runtime.

Bugs

BL-608 Timeouts (connection, idle) for datasources needs to be in seconds and not in milliseconds to adhere to cfconfig

BL-609 BoxLang resolvers do not allow class paths to have `-` in them.

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:

{
  "scheduler": {
    "executor": "scheduled-tasks",
    "cacheName": "default",
    "schedulers": [],
    "tasks": {}
  }
}

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.

"executor": "scheduled-tasks"

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.

"cacheName": "default"

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}.

"schedulers": [
  "${user-dir}/schedulers/MainScheduler.bx",
  "/path/to/custom/MyScheduler.bx"
]

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

• Executors - Configure the thread pools used by the scheduler

• Caches - Configure caches used for task coordination

• Logging - Configure logging for scheduler operations

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 Florida International University.

He is the CEO of Ortus Solutions, 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 www.luismajano.com

Luis is passionate about Jesus, tennis, golf, volleyball, and anything electronic. Random Author Facts:

• He played volleyball in the Salvadorean National Team at the tender age of 17

• His favorite books are The Lord of the Rings and The Hobbit (Geek!)

• His first computer was a Texas Instruments TI-99 that his parents gave him in 1986. After some time digesting his very first BASIC book, he had written his own tic-tac-toe game at the age of 9. (Extra geek!)

• He has a geek love for circuits, microcontrollers, and overall embedded systems.

• He has, as of late, become a fan of organic gardening.

Keep Jesus number one in your life and in your heart. I did and it changed my life from desolation, defeat and failure to an abundant life full of love, thankfulness, joy and overwhelming peace. As this world breathes failure and fear upon any life, Jesus brings power, love and a sound mind to everybody!

"Trust in the LORD with all your heart, and do not lean on your own understanding." Proverbs 3:5

SyntaxHighlighter

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

Installation

npm install brush-boxlang

Example

SyntaxHighlighter.brushes.BoxLang = require('brush-boxlang').default;
SyntaxHighlighter.all();

Versioning Schema

BoxLang is maintained under the 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.

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

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.

Charitable Proceeds‌

10% of the proceeds of this book will go to charity to support orphaned kids in El Salvador - . So please donate and purchase the printed version of this book; every book sold can help a child for almost two months.‌

Shalom Children's Home

The Shalom Children's Home () is one of the ministries that are dear to our hearts located in El Salvador. During the 12-year civil war that ended in 1990, many children were left orphaned or abandoned by parents who fled El Salvador. The Benners saw the need to help these children and received 13 in 1982. Little by little, more children came on their own, churches and the government brought children to them for care, and the Shalom Children’s Home was founded.

Shalom now cares for over 80 children in El Salvador, from newborns to 18 years old. They receive shelter, clothing, food, medical care, education, and life skills training in a Christian environment. A child sponsorship program supports the home.‌

We have supported Shalom since 2010; it is a place of blessings for many children in El Salvador who either have no families or have been abandoned. This is a good earth to seed and plant.

New Features

• Add parse() helper methods directly to runtime, which returns parse result

• new security configuration item: populateServerSystemScope that can allow or not the population of the server.system scope or not

Improvements

• Create links to BoxLang modules

• match getHTTPTimeString() and default time to now

• Work harder to return partial AST on invalid parse

• Error executing dump template [/dump/html/BoxClass.bxm]

• Compat - Move Legacy Date Format Interception to Module-Specific Interception Point

• allow box class to be looped over as collection

• Rework event bus interceptors to accelerate during executions

• Compat - Allow handling of decimals where timespan is used

• Allow Numeric ApplicationTimeout assignment to to be decimal

Bugs

• BoxLang date time not accepted by JDBC as a date object

• contracting path doesn't work if casing of mapping doesn't match casing of abs path

• sessionInvalidate() "Cannot invoke String.length() because "s" is null"

• Some methods not found in java interop

• string functions accepting null

• onMissingTemplate event mystyped as missingtemplate

• fileExists() not working with relative paths

• optional capture groups throw NPE in reReplace()

• array length incorrect for xml nodes

• Numeric Session Timeout Values Should Be Duration of Days not Seconds

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

• ColdBox Platform, TestBox, and ContentBox CMS Integrations

• Integrated servlet server with rewrite capabilities

• Ability to create command recipes and execution

• Ability to interact with users via CLI and create workflows and

  installers

• Ability to execute workflows and tasks

Installation

CommandBox is a Java-based executable running on the most recent desktop operating systems (Linux, Mac OS X, Windows). Since it is a command line tool that uses a shell interface, it does not require an operating system using a GUI. Below is a simple guideline to get you up and running, but an can be found here:

Requirements

• 256MB+ RAM

• 250MB+ free hard drive space

• Multi-core CPU recommended

• JRE/JDK 21+

Getting Started

We have created a small to give you enough skills to move forward with any CommandBox development. You can find it here:

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

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

BoxLang MiniServer on Ubuntu 24.04 LTS

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang MiniServer. Additionally, you can connect to your Virtual Machine to develop and manage it. .

BoxLang with CommandBox on Ubuntu 24.04 LTS

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang as the Engine in CommandBox. Also, you can connect to your Virtual Machine to manage and boost your Software Development Life Cycle (SDLC). .

Windows Server 2019 based

BoxLang MiniServer on Windows 2019

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang MiniServer. Additionally, you can connect to your Virtual Machine to develop and manage it. .

BoxLang with CommandBox on Windows 2019

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang as the Engine in CommandBox. Also, you can connect to your Virtual Machine to manage and boost your Software Development Life Cycle (SDLC). .

Red Hat 8 based

BoxLang MiniServer on Red Hat 8

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang MiniServer. Additionally, you can connect to your Virtual Machine to develop and manage it. .

BoxLang with CommandBox on Red Hat 8

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang as the Engine in CommandBox. Also, you can connect to your Virtual Machine to manage and boost your Software Development Life Cycle (SDLC). .

Learn how to deploy Windows Server-based BoxLang Cloud Servers .

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

BoxLang MiniServer on Ubuntu 24.04 LTS

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang MiniServer. Additionally, you can connect to your Virtual Machine to develop and manage it. .

BoxLang with CommandBox on Ubuntu 24.04 LTS

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang as the Engine in CommandBox. Also, you can connect to your Virtual Machine to manage and boost your Software Development Life Cycle (SDLC). .

Windows Server 2019 based

BoxLang MiniServer on Windows 2019

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang MiniServer. Additionally, you can connect to your Virtual Machine to develop and manage it. .

BoxLang with CommandBox on Windows 2019

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang as the Engine in CommandBox. Also, you can connect to your Virtual Machine to manage and boost your Software Development Life Cycle (SDLC). .

Red Hat 8 based

BoxLang MiniServer on Red Hat 8

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang MiniServer. Additionally, you can connect to your Virtual Machine to develop and manage it. .

BoxLang with CommandBox on Red Hat 8

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang as the Engine in CommandBox. Also, you can connect to your Virtual Machine to manage and boost your Software Development Life Cycle (SDLC). .

Learn how to deploy Windows Server-based BoxLang Cloud Servers .

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

• asm : We will directly compile your BoxLang source to Java bytecode (Default)

AST Capture

If enabled, it will activate the AST capture interceptor and on parse it will create a /grapher/data folder in your project with useful AST JSON captures. The default is false.

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

New Features

BL-123 Implement multiple statements inside queries

BL-383 new bif: datasourceRegister() to allow for easy saas integrations to create datasources

BL-658 MIgrate AST Capture to it's own experimental flag

BL-748 Add getApplicationContext() method on all contexts for convenience, especially when calling from CF/BL

Improvement

BL-730 Miniserver needs to 302 redirect when hitting a directory without the trailing slash

BL-734 Broadcast Transactional events at the Application listener-level

BL-735 Allow unregistering a java class (IInterceptor) from an InterceptorPool

BL-737 Add getRequestContext() method on all contexts for convenience, especially when calling from CF/BL

BL-738 Allow output from functional wrappers

BL-740 Autocast simple values to Keys when calling java methods from BL

BL-741 Allow :: static access to be chained to any expression

BL-746 Add toLegacyDate BIF and Member Function to Compat module

BL-751 Make generated getters return null when property is not initialized

BL-116 Implement unfinished query options

Bug

BL-694 Fix tests that fail when using ASM

BL-695 large json fails to deserialise with bx-compat

BL-714 Add Whitespace Management

BL-731 dump errors with compat installed due to null variable

BL-733 RandRange seems to never return upper range

BL-736 JDBC Transaction listeners not firing upon transaction event announcement

BL-739 shebang checks in BoxRunner don't nicely handle invalid file paths

BL-743 WDDX not parsing booleans correctly

BL-744 Cannot cast ortus.boxlang.runtime.types.DateTime to java.util.Date

BL-745 parseDateTime failing

BL-747 for (sentinel) loop is evaluating the step/increment expression one final time too many when a break is used

BL-752 error using negative indices to get characters from strings

BL-754 error: integer number too large

BL-755 SerializeJSON not working with named params

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.

• New validClassExtensions configuration to specify permissible class extensions.

• A new security configuration section designed to disallow BIFs, Components, and Imports, enhancing security.

New Feature

BL-617 arrayFind, arrayFindNoCase value closures, accept the value and now the index of the item as the second param

BL-626 New configuration: validBoxLangTemplates to determine which templates the Runnable Loader can process

BL-627 New configuration: validClassExtensions to determine which class extensions to work with

BL-629 New security configuration section for disallowing: BIFS, Components, Imports

BL-630 Internal refactor to make the class locator and resolvers have a life-cycle based on the runtime and not alone

Improvement

BL-611 Remove debugmode capture on miniserver, delegate to the core runtime.

BL-622 Consolidate CastAttempt and Attempt into a hierarchy

BL-623 New DynamicFunction type that can be used to generate dynamic BoxLang functions using Java Lambda proxies. Great for code generation

Bug

BL-614 Import nested classes

BL-615 Java static funcitons not behaving as expected

BL-616 array.find does not use cf rules to convert result of predicate to boolean

BL-619 QueryColumnType doesn't handle "idstamp" (mssql)

BL-620 static scope in application.cfc not initialized before psuedoConstructor runs

BL-624 Auto-escaping of {} in regex needs to ignore already-escaped braces

BL-625 Instead of removing special chars from Java FQN, replace with __ to avoid conflicts

BL-628 Tag expressions not parsing inside template island inside braces

BL-631 duplicate() doesn't work on empty structs

BL-633 randrange() not inclusive of upper bound

BL-634 array.find - can't cast closure to string

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.

Usage

Make sure you have installed the OS version of BoxLang so you get all the tools installed as well. Please note that the action command funnels through the boxlang binary, so you can use all the CLI arguments for boxlang runner.

// Using the script
boxlang compile
    --source /path/to/webroot/index.cfm
    --target /path/to/compiled-webroot/index.cfm
    --basePath /path/to/webroot

// Using the full path to jar
java -cp boxlang-1.0.0.jar ortus.boxlang.compiler.BXCompiler
--source /path/to/webroot/index.cfm
--target /path/to/compiled-webroot/index.cfm
--basePath /path/to/webroot

Note, for the code to run, the compiled file needs to have the exact same path on disk as the original file. That means you’ll either need to copy the pre-compiled files back over to the original location or just point the source and target at the same place. BE WARNED: this will overwrite the source code! So pay attention.

Directory

And an entire directory like so:

// Using the script
boxlang compile
    --source /path/to/webroot/
    --target /path/to/compiled-webroot/
    --basePath /path/to/webroot

// Using the full path to the jar
java -cp boxlang-1.0.0.jar ortus.boxlang.compiler.BXCompiler
--source /path/to/webroot/
--target /path/to/compiled-webroot/
--basePath /path/to/webroot

Also note, when pre-compiling an entire directory, the tool doesn’t touch non-code files, so if your target is a separate folder, that new folder won’t contain images, js files, etc. The typical use case for this would be in a CI build or similar, where you would override the code files in place.

CLI Options

• --basePath path The path to use for all base operations that require relative paths.

• --mapping dot_notation If there is a mapping name to the source folder, then add it here

• --source file/directory A file or directory to compile.

• --stopOnError or --stopOnError boolean to stop execution if an error occurs. Otherwise, it ignores it, logs it, and continues compiling.

• --target path Optional; if not passed, it will be compiled and put in the same location as the source. This is a directory where the compiled files will be placed.

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

• A-la-carte via query execution calls

// The registered global datasources in the language
// The key is the name of the datasource and the value is a struct of the datasource settings
"datasources": {
	"testDB": {
		"driver": "derby",
		"connectionString": "jdbc:derby:memory:testDB;create=true"
	}
	"testdatasource": {
	 	  "driver": "derby",
	 	  "host": "localhost",
	 	  "port": 3306,
	 	  "database": "test"
	}
},

The key is the name of the datasource and the value is a struct of configuration for the JDBC connection. Most of the items can be different depending on the JDBC module and driver used. However, at the end of the day we need to know at least either the driver , the connectionString or individual items of the connection. Check out our guide on defining datasources here.

Default Datasource

The name of the datasource in the datasources configuration struct, which will act as the default one for the entire runtime.

// You can assign a global default datasource to be used in the language
"defaultDatasource": "main",
"datasources" : {
    "main" : {...}
}

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"
                }
            ]
        }
    }
}

This CLI tool will allow you to transpile your CFML code into BoxLang native code. This is a great way to move forward and leverage BoxLang for your future projects. It will also transpile your Tag-based CFCs into the script.

Usage

Make sure you have installed the OS version of BoxLang so you get all the tools installed as well. Please note that the action command funnels through the boxlang binary, so you can use all the CLI arguments for boxlang runner.

You can call the tool using our script or the full path to the jar.

// Using the script
boxlang cftranspile <options here>

// Using the full path to the jar
java -cp boxlang-1.0.0.jar ortus.boxlang.compiler.CFTranspiler  <options here>

Examples

// Using the script
boxlang cftranspile
    --source /path/to/file.cfc
    --target /path/to/file.bx

// Using the full path
java -cp boxlang-1.0.0.jar ortus.boxlang.compiler.CFTranspiler
--source /path/to/file.cfc
--target /path/to/file.bx

(If you leave off the target file extension, the tool will automatically append the correct one based on the source file type). You can also convert an entire folder like so:

// Using the script
boxlang cftranspile
    --source /path/to/CF/code
    --target /path/to/BL/code
    --stopOnError

// Using the full path
java -cp boxlang-1.0.0.jar ortus.boxlang.compiler.CFTranspiler
--source /path/to/CF/code
--target /path/to/BL/code
--stopOnError

Known issues right now are

• It may not have the same whitespace you had in the original source. Since our Abstract Syntax Tree (AST) doesn’t store whitespace from script-based code, you’ll get whatever formatting the tool applies. That said, we do plan to make some of that configurable in regards to tabs v, spaces, etc.

• ALL function and class annotations are converted to the new @foo bar syntax, but we’ll update that eventually to keep inline annotations as inline and only move CF “JavaDoc” style annotations to pre-annotations.

• All CFCs will be converted to script. This is designed as BoxLang plans to enforce classes to only be written in script.

CLI Options

• --source path A file or directory to transpile to BoxLang

• --target path The target file or directory to store the new BoxLang source. Extension not required.

• --stopOnError or --stopOnError boolean Stop execution if an error is encountered or continue processing. Defaults to false

🚀 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

BL-117 trace bif and component

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

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

BL-688 new computeAttachmentIfAbsent, to make fluent attachments on IBoxAttachable implementations

BL-689 refactor escapeHTML to the lib we use instead of multiple functions

BL-698 DateTime objects don't have a len member method

Improvements

BL-672 Add line break in dump console output

BL-673 Allow access to super scope from thread

BL-683 reuse config of validTemplateExtensions

BL-686 Add ability to deep merge config items from the environment.

BL-687 track current request context in thread

BL-690 improve concurrency of session ID creation

BL-693 Move from immutable verbiage to unmodifiable

BL-703 Need to set explicit `/` path on session cookies

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

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

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

Bugs

BL-640 bx-compat-cfml datediff fails to convert string

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

BL-663 NOT operator precedence not grabbing operators in the chain

BL-668 Java Doc implementation is stricter that ACF and Lucee

BL-671 Missed module class hierarchy to have the runtime class loader as the parent

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

BL-676 Dump not showing BoxLang type NullValue as null

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

BL-680 boxclass dump looping construct exception

BL-696 java class method not found

BL-697 argument collection optional param is null

BL-701 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.

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

BL-704 cannot get lenght of native java date time objects

BL-705 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 JSR223 scripting, and much more.

import java.lang.System
import java.util.Date as MyDate
import ortus.boxlang.runtime.types.Array

start = new MyDate().getTime()
num = 1000
myArray = []
myCopy = Array.copyOf( myArray )

printLn( myCopy.size() )

JSR-223

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

Multi-Runtime

BoxLang has been designed to run in many different runtimes 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:

println( "Hello from BoxLang, printed on: " & now() )

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

Hello from BoxLang, printed on: {ts '2024-05-21 22:07:19'}

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.

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.

Amazon Web Services

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

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 (Coming Soon)

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.

One convenient feature of our official BoxLang VS Code extension is the built-in MiniServer. 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.

When you click the “+” icon, you will be prompted with a series of inputs to help configure your server. After filling out the prompts, your new MiniServer will start-up automatically. Once running, a browser window should open to the port the server configures.

MiniServer Control Icons

Now that your server is configured, it should show up in the list of available servers. You will see information about the status of your server here as well as some icons to be able to interact with it. Hover your mouse over the server to see what options are available. When the server is stopped you will see something like this:

• Delete

• Edit (The name)

• Run Server

When the server is running you will see something like this:

• Debug

• Open Browser

• Stop

Trying Out Your App

The BoxLang MiniServer is a real life BoxLang runtime. That means you can configure and run your code just like you would any other web server. The great part is it only took 5 seconds to get setup! This is great for quickly spinning up servers to test out an idea or even locally serve files for whatever reason or run small microservices.

Another advantage of the MiniServer is that it makes debugging your web app very easy. You can spin up a webserver and start debugging your templates almost instantly. Just go add breakpoints wherever you want, hit your code in the browser and voila! You are now debuging your live MiniServer BoxLang application!

Wrapping Up

In conclusion, the MiniServer is a pretty cool feature provided by the official BoxLang VS Code extension. As a member of the BoxLang community your feedback is always valuable to us. Download the extension, spin up a MiniServer, throw some breakpoints in, and let us know what you think!

Introducing BoxLang 1.0.0 Beta 24!

We’re excited to announce the release of Beta 24, packed with powerful new features, essential bug fixes, and impactful improvements that enhance performance and security. This release brings more robust logging capabilities, enhanced configuration flexibility, and new query-handling methods to streamline your development experience. We’ve also squashed several parsing bugs, ensuring smoother code execution.

Whether you’re optimizing your runtime with custom logging encoders or leveraging the new queryColumnList for seamless data manipulation, Beta 24 is designed to empower developers with a more secure, customizable, and efficient development environment.

🐞 Bug Fixes

• BL-797: Parsing issue fixed when using a < symbol before a tag. No more parsing hiccups!

• BL-798: = sign after an if tag? No problem now! Fixed to handle this scenario smoothly.

• BL-799: Parentheses confusion resolved! Opening parentheses (afterword operators will no longer be mistaken for function calls.

• BL-800: Environmental safety improved: BOXLANG_DEBUG will now be parsed only if non-null to prevent unexpected behavior.

✨ New Features

Improved Logging

BoxLang's logging features have been completely revamped in preparation for its stable release. You also have fine-grain control over them, and module developers will be able to register and leverage custom loggers and appenders.

Please note that the logsDirectory setting has been moved from the root of the boxlang.json to the new logging section.

Check out the new configuration:

JSON Anyone?

We have added support for log files. You can now switch the default encoder for the log files from text to json and see the JSON log files in full splendor!

• BL-792: Introducing CFConfig support and named loggers for more precise control over your logging setup!

• BL-793: Added the ability to configure logging items, giving you more flexibility in managing your logs.

• BL-803: Choose your logging format! You can now select text and JSON logging encoders for better runtime output customization.

📈 Improvements

• BL-782: Refined the LoggingService to encapsulate all logging characteristics, streamlining log management.

• BL-783: Strengthened security by disabling absolute path logging and prohibiting custom log extensions. Your logs are safer now!

• BL-785: Upgraded logging to follow ISO8601 date/time format and threading standards for more standardized logs.

• BL-786: Replaced FileAppender with RollingFileAppender to better handle large log files through automatic rotation.

• BL-795: Introduced queryColumnList BIF and a columnList() member method for easier Query column management.

• BL-804: Enhanced support for customTagPaths in Application.cfc/bx, expanding customization capabilities.

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

• onTransactionRollback

• onTransactionSetSavepoint

• onTransactionAcquire*

• onTransactionRelease*

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

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:

The core impetus of BoxLang is to grow in a hierarchical approach to target specific runtimes with specific behavior for particular runtimes. For example, the concept of a FORM, URL scope, or web functions and components are only available to those runtimes that offer web support.

Just because a runtime is not listed here doesn't mean BoxLang can't run there. These are just a collection of officially supported runtimes. You can use the core runtime and make it run ANYWHERE the JVM can be run. You can embed it now in Android, Azure, OpenWhisk, and more. However, once we have official runtimes, we will post them here.

Third-Party Runtimes

We love our community, and if you have created custom runtimes for BoxLang, please let us know, and we will add them here.

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:

Anything placed in the allowed extensions overrides the disallowed extensions array

Disallowed Imports

An array of regex patterns (case-sensitive) that will try to be matched to imports or to creation of classes. If they match the patterns a security exception wil be thrown.

Disallowed BIFS

An array of BIF names that will be disallowed from execution.

Disallowed Components

An array of Component names that will be disallowed from execution.

Disallowed File Operation Extensions

The list of file extensions that are not allowed to be uploaded. Also enforced by file relocation operations ( e.g. copy/move ). By default, in the CLI and Lambda runtimes, we don't restrict, but you can :)

In Web runtimes, the following extensions are disallowed by default. Unlike other engines this list does not apply to just uploads but applies to File move and copy operations. This is enforced to prevent a bad actor from uploading a file with one extension and being able to copy it to another that is executable.

Note: If you wish to override a single extension you may do so by placing the extension in the allowedFileOperationExtensions setting in the application:

populateServerSystemScope

This is a boolean flag that, if enabled, will populate the server.system scope with the Java environment and properties. If disabled, it will not populate them and users will only be able to get environment and properties via the getSystemSetting() BIF.

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.

Configuring CommandBox

To start we will need to make sure our server is configured properly. You can do this one of two ways.

1. We can add JVMArgs to the CLI when starting a BoxLang CommandBox server:

1. The alternative approach is to add some configuration to our server.json definition:

In these examples I’ve used port 8888 as the port we want the debugger to connect to control the CommandBox server through. You can specify whatever open port you want. You just need to make sure that you use the same one at every step.

Once you start your server it should run as normal.

Configuring VS Code

Now that your server is configured, we need to setup VS Code. We will need to update your .vscode/launch.json. If you don’t see this file, you can create it yourself and VS Code will pick it up.

We want the launch.json to look something like this:

That's it. Now VSCode will know to what port to connect to your debugger running inside of CommandBox.

Starting a Debug Session

At this point your server is configured, it’s running, and you have just added a launch configuration. The next step is to run the debugger. All we need to do is open up the debug tab in our side-panel and select the correct configuration, which is the one we just added Debug CommandBox

Now that we have everything setup all we need to do is press “play” or hit f5 and VS Code will fire up the BoxLang debugger and attach to your BoxLang server. That's it! Go add some breakpoints, go create some bugs and then fix them!

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

BoxLang MiniServer on Ubuntu 24.04 LTS

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang MiniServer. Additionally, you can connect to your Virtual Machine to develop and manage it. .

BoxLang with CommandBox on Ubuntu 24.04 LTS

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang as the Engine in CommandBox. Also, you can connect to your Virtual Machine to manage and boost your Software Development Life Cycle (SDLC). Review.

Windows Server 2019 based

BoxLang MiniServer on Windows 2019

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang MiniServer. Additionally, you can connect to your Virtual Machine to develop and manage it. .

BoxLang with CommandBox on Windows 2019

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang as the Engine in CommandBox. Also, you can connect to your Virtual Machine to manage and boost your Software Development Life Cycle (SDLC). .

Red Hat 8 based

BoxLang MiniServer on Red Hat 8

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang MiniServer. Additionally, you can connect to your Virtual Machine to develop and manage it. .

BoxLang with CommandBox on Red Hat 8

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang as the Engine in CommandBox. Also, you can connect to your Virtual Machine to manage and boost your Software Development Life Cycle (SDLC). .

Learn how to deploy Windows Server-based BoxLang Cloud Servers .

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:

Available Executor Types

The available types of executors you can register in BoxLang are:

As long as they implement the executor services interfaces, you can use them in BoxLang.

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

BL-142 Writedump output support

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

BL-508 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.

BL-489 Ability to mark a @BoxBif as excluded from documentation

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

BL-504 New dump template for Java instants

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

BL-507 dump showUDFs

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

Improvements

BL-497 Simplify BoxLang class dumps

BL-499 Add output and format to dump

BL-501 Some BIFs not fully supporting BigDecimal values

BL-517 access e.cause as shortcut for e.getCause()

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

Bugs

BL-223 queryaddcolumn ignores the datatype

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

BL-492 structnew( "linked" ) doesn't work

BL-493 argumentCollection doesn't work with implicit constructor

BL-494 directory component must always return query

BL-498 BoxNewTransformer using hard-coded context name

BL-500 toNumeric() not accepting radix values of 2-36

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

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

BL-506 final keyword not working on this scope

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

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

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

BL-512 DuplicationUtil not doing deep clones of structs according to all types

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

BL-514 remote access not treated as public but as private for functions

BL-515 Interfaces don't support multiple inheritance

BL-516 CFC source type not detected correctly for abstract or final classes

BL-521 Metadata with : in them in cfml mode not treated correctly

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

The BoxLang CFML Feature audit tool is a CLI tool that will scan your source code and give you a compatibility report. This will allow you to see if your CFML code will run natively in BoxLang or if any BIFs or Components are required. Like the other tools, this is based on our BL AST (BoxLang Abstract Syntax Tree), so it should be accurate and not require anything like regex. It’s using the actual BL ANTLR parsers.

Install the Compatibility Modules

Before you run the tool, install the appropriate BoxLang modules so our tool can also account for those module collaborations. We recommend the following to simulate a CFML server:

# Install the modules to simulate a CFML server (Adobe, Lucee)
install-bx-module bx-compat-cfml bx-password-encrypt bx-esapi bx-image bx-ini bx-mail bx-pdf bx-unsafe-evaluate bx-wddx bx-web-support

Features

This CLI tool will scan

• a single file

• or a folder of files recursively (in parallel)

and will track:

• what BIFs you are using

• What Components (Tags) you are using

including the

• file name where it is used

• line number it was used on

• The module that BIF/component is from

• Whether or not that feature is missing from BoxLang currently (true/false)

Data tracked can be

• every occurrence of a component or BIF

• aggregate of what BIFs/components were used per file

• aggregate summary of what BIFs/components were used across all files

and can be

• printed to console

• and/or written to CSV report file

Usage

Make sure you have installed the OS version of BoxLang so you get all the tools installed as well. Please note that the action command funnels through the boxlang binary, so you can use all the CLI arguments for boxlang runner.

You can call the tool using our script or the full path to the jar.

// Using the script
boxlang featureAudit <options here>

// Using the full path to the jar
java -cp boxlang-1.0.0.jar ortus.boxlang.compiler.FeatureAudit  <options here>

CLI Options

• --source - Defaults to working directory. If supplied, it must be followed by an absolute path or a path relative to the working directory.

• --missing - Filter results to only show BIFs and Components which are missing from BoxLang.

• --aggregate - Instead of showing every usage instance, roll-up counts at the file level by default.

• --aggregate summary - If the arg “summary” is passed after the aggregate flag, we will roll the results up even further to include all files processed. In “summary” mode, the total number of files processed will also be output to the console, along with a breakdown of the number of file extensions encountered.

• --quiet - Do not output the details of what was found on the console. Use in conjunction with the report path arg if you want to write out a report file. Even in quiet mode, each file processed will be output.

• --reportFile - An absolute or relative (to the working dir) file path to write the data matching your filters and aggregate settings in a CSV format. Intermediate folders will be created. If the filename does not end with .csv, it will be appended.

  • The CSV columns, when not aggregating the data, will be File,Name,Type,Module,Missing,Line

  • The CSV columns, when aggregating data at a per-file level, will be: File,Name,Type,Module,Missing,Count

  • The CSV columns, when aggregating data at a summary level, will be: Name,Type,Module,Missing,Count

Examples

Get a full report of all BIFs and Components used in a file

// Using the script
boxlang featureAudit --source includes/myFile.cfm

// Using the full path
java -cp boxlang-1.0.0.jar ortus.boxlang.compiler.FeatureAudit --source includes/myFile.cfm

Scan all your models for missing BIFs and Components

// Using the script
boxlang featureAudit --source ./models/ --missing

// Using the full path
java -cp boxlang-1.0.0.jar ortus.boxlang.compiler.FeatureAudit --source ./models/ --missing

Same as above, but aggregate results per file and write results to a CSV report

// Using the script
boxlang featureAudit --source ./models/ --missing --aggregate --quiet --reportFile /path/to/models-missing-features.csv

// Uisng the Full path
java -cp boxlang-1.0.0.jar ortus.boxlang.compiler.FeatureAudit --source ./models/ --missing --aggregate --quiet --reportFile /path/to/models-missing-features.csv

Get a summary level aggregate report of all missing features in ColdBox output to the console

// Using the script
boxlang featureAudit --source ./coldbox/ --missing --aggregate summary

// Using the full path
java -cp boxlang-1.0.0.jar ortus.boxlang.compiler.FeatureAudit --source ./coldbox/ --missing --aggregate summary

BoxLang Betas are released weekly.

This is our seventh beta marker and we are incredibly excited of this beta marker since it now fully supports ColdBox for operation.

Improvements

BL-376 web support error template only shows details of exceptions if IN debug mode else secure by default

If you are using the MiniServer or CommandBox, then if an exception occurs, only in DEBUG MODE, will you get the exception stacktrace, details and more. This makes it secure by default of not exposing any potential data for exceptions.

BL-392 Consolidate the runtime into services without the need of getInstance()

A simple internal improvement to improve locking and instance usage.

New Features

BL-374 threadNew()

This is a new BIF for BoxLang. We have a way to create threads using the thread{} component in both script and template, and we have threadJoin(), threadTerminate() but we never had a way to create threads functionally.

Signature

threadNew( lambda/closure, [attributes={}], [threadName], [priority=normal] )

Examples

threadNew( () => {
    printLn( "thread is done!" );
    sleep( 1000 );
    result = "done";
} );

threadNew( () => calculateOrder( invoice ), {invoice:myData}, "order-builder", "high" )

Please note that the attributes is a struct of data that we will bind into the thread's local scope.

BL-388 Stream type and collector member methods

Java streams are now a native BoxLang type, which for now we don’t try to coerce, but simply match any existing instance or subclass of java.lang.Stream. This means we can now add member methods to ANY stream from BoxLang source code and make Streams also dynamic:

• .toBXArray()

• .toBXStruct( [String type] )

• .toBXQuery( [Query query] )

• .toBXList( [String delimiter] )

Examples

Collect stream of objects into BoxLang array

foods = [ 'apples', 'bananas', 'pizza', 'tacos' ];
result = foods.stream().parallel().toBXArray();

import java.util.stream.IntStream;
result = IntStream.range(1, 6).toBXArray();

Collect stream of Map entries into a struct

foods = { 'apples' : 'healthy', 'bananas' : 'healthy', 'pizza' : 'junk', 'tacos' : 'junk' };
result = foods.entrySet()
    .stream()
    .filter( e -> e.getValue() == 'healthy' )
    .toBXStruct();


data = [ 'd' : '', 'c' : '', 'b' : '', 'a' : '' ];
result = data.entrySet().stream().toBXStruct( "sorted" );

Collect an array of structs into an existing query object

qry = queryNew( "name,title", "varchar,varchar" );

[
  	{ name: "Brad", title: "Developer" },
  	{ name: "Luis", title: "CEO" },
  	{ name: "Jorge", title: "PM" }
].stream().toBXQuery( qry );

Collect a stream of objects into a list

foods = [ 'apples', 'bananas', 'pizza', true ];
foods.stream().toBXList();

[ "www", "google", "com" ].stream().toBXList( "." )

BL-390 orThrow( type, message ) for attempts

Attempts now allow you to do a custom exception type and message. Check out the attempt docs.

BL-391 ifSuccessful() alias to ifPresent() on attempts

Attempts now allow you to have an alias to ifPresent() that's fluent: ifSuccessful(). Check out the attempt docs.

Bugs

BL-373 Parser detection for unparsed tokens only works if there are 2 or more tokens left

BL-377 Declaring UDFs in function context doesn't always work

BL-378 CFConfig datasources aren't importing due to lack of support for the 'dbdriver' key

BL-379 Runtime can deadlock due to syncronized methods

BL-380 NPE calling isNumeric()

BL-381 JSONSerialize() errors when useSecureJSONPrefix not a boolean

BL-385 Cannot call getWriter(), getOutputStream() already called

BL-386 empty url vars coming through as null

Tasks

BL-372 Create tests for al valid and invalid dot and array access expressions

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.

Supported Platforms

We provide a collection of extensions and modules to enhance your BoxLang development experience on many different IDE platforms. The official IDE for BoxLang is based on Visual Studio Code technology and can be installed on any platform that supports VS Code Extensions:

• Visual Studio Code - The primary development platform

• Cursor - AI-powered code editor with BoxLang support

• Windsurf - Modern development environment

• Any IDE supporting Open VSX - Extended compatibility

BoxLang IDE Extension

Complete language support with IntelliSense, debugging, and AI-powered development assistance.

BoxLang Theme Extension

Beautiful dark and light themes specifically crafted for BoxLang syntax highlighting and optimal coding experience.

🌐 Web-Based Development

BoxLang Monaco Editor

Monaco Editor language support for BoxLang - providing syntax highlighting, IntelliSense, and custom themes for web-based BoxLang development and online code editors.

BoxLang TextMate Bundle

TextMate grammar bundle providing comprehensive syntax highlighting and snippets for BoxLang development across TextMate-compatible editors.

🛠️ Command Line Tools

Powerful CLI utilities for BoxLang development, compilation, debugging, and migration tasks.

BoxLang Compiler

Command-line compiler for BoxLang source code with optimization and build management capabilities.

BoxLang Debugger

Built-in debugging tools and utilities for troubleshooting BoxLang applications with breakpoint support and variable inspection.

CFML Feature Audit

Comprehensive auditing tool to analyze CFML codebases and assess BoxLang compatibility and migration readiness.

CFML to BoxLang Transpiler

Automated migration tool for converting CFML code to BoxLang syntax with intelligent transformation and compatibility checks.

🎨 Syntax Highlighting

Enhanced syntax highlighting solutions for various platforms and applications.

Multi-Platform Highlighters

Collection of syntax highlighters for embedding BoxLang code in documentation, websites, and applications across different platforms and libraries.

🚀 Quick Start Guide

For New BoxLang Developers

1. Install VS Code - Download from code.visualstudio.com

2. Install BoxLang Extension - Search for "BoxLang" in the Extensions marketplace

3. Install BoxLang Theme - Apply beautiful BoxLang-specific color schemes

4. Start Coding - Create your first .bx file and experience full language support

For CFML Developers

1. Audit Your Codebase - Use the CFML Feature Audit tool to assess migration readiness

2. Transpile Code - Convert existing CFML to BoxLang using the automated transpiler

3. Set Up Development Environment - Install the complete BoxLang toolchain

4. Migrate Gradually - Use both tools to transition your applications systematically

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.

boxlang.json

Once you startup a runtime, the runtime will find the BOXLANG_HOMEand create the config/boxlang.jsonfile with the defaults that it ships with. You may also change the granular config settings at runtime using the environment or Java properties by prefixing any configuration item with BOXLANG_or boxlang. See below.

server status property=serverHome

Runtime Home Directory

By default, the BoxLang home directory is a .boxlang/ directory inside your user's home directory. For instance, on a Ubuntu machine, this might be /home/elpete/.boxlang/ if you are executing BoxLang under the elpete user account.

ℹ️ The BoxLang home can be adjusted on startup via a --home flag:

boxlang --home /path/to/boxlang-home

By allowing a custom home directory, you can manage multiple BoxLang runtimes and allow:

1. custom, per-runtime configuration

2. a custom set of BoxLang modules

3. etc

Boxlang.json Reference

Here is the latest reference of the current default boxlang.json file:

https://github.com/ortus-boxlang/BoxLang/blob/development/src/main/resources/config/boxlang.json

Internal Variables

The following are the internal variable substitutions you can use in any value:

 * ${boxlang-home} - The BoxLang home directory
 * ${user-home} - The user's home directory
 * ${user-dir} - The user's current directory
 * ${java-temp} - The java temp directory

Here is an example:

"classGenerationDirectory": "${boxlang-home}/classes",

Environmental/Properties Configuration

BoxLang gives you the ability to override any of the runtime configuration or module settings via environment variables or Java system properties. For example adding an environment variable of boxlang.security.allowedFileOperationExtensions=.exe,.sh would override the disallowed defaults, and allow users to upload and rename files with these extensions ( not a good idea! ).

The variable names can be either snake-cased or dot-delimited. For example BOXLANG_DEBUGMODE=true will work the same as boxlang.debugMode=true to set the entire runtime in to debug mode.

This convention allows you to make granular changes to sub-segments of the configuration without overriding parent items. JSON is also allowed when overriding config settings. For example, if I wanted to set the runtime logging level to trace without putting the runtime in to DebugMode, I could set the environment variable: boxlang.logging.loggers.runtime.level=TRACE or add the JVM arg -Dboxlang.logging.loggers.runtime.level=TRACE

Environment Variable Substitution

BoxLang supports environment variable substitution using the syntax ${env.environment_variable_name:default}. For example, using ${env.MYSQL_HOST:localhost} will result in the value of the MYSQL_HOST environment variable, if found, or fall back to the localhost value if the environment variable is not defined.

Inside your boxlang.json configuration file, you can use this to populate datasource credential secrets:

{
    // ...
    "datasources": {
        "mySqlServerDB": {
            driver: "mssql",
            host: "localhost",
            port: "${env.MSSQL_PORT:1433}",
            database: "myDB",
            username: "${env.MSSQL_USERNAME:sa}",
            password: "${env.MSSQL_PASSWORD:123456Password}"
        }
    },

}

Configuration Segments

Here, you will find each segment and its configuration details.

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

• Component Support - Special highlighting for BoxLang components (<bx:component> tags)

• Eye-friendly - Carefully selected contrast ratios for comfortable viewing

📦 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: BoxLang Developer Pack

OpenVSX Registry: BoxLang Developer Pack

# Install the complete developer pack
code --install-extension ortus-solutions.vscode-boxlang-developer-pack

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 VS Code Marketplace:

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 and select your preferred BoxLang theme

OpenVSX Registry

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

Command Line Installation

# VS Code
code --install-extension ortus-solutions.vscode-boxlang-theme

# VS Code compatible editors
cursor --install-extension ortus-solutions.vscode-boxlang-theme

🎯 Recommended Settings

Enable these VS Code settings for the best theme experience:

{
  "editor.semanticHighlighting.enabled": true,
  "editor.bracketPairColorization.enabled": true,
  "editor.guides.bracketPairs": "active",
  "editor.fontFamily": "Fira Code, 'Cascadia Code', Consolas, 'Courier New'",
  "editor.fontLigatures": true,
  "editor.fontSize": 14,
  "editor.lineHeight": 1.5
}

🔧 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

3. Select either:

   • BoxLang Dark (Neon) - For high contrast dark experience

   • BoxLang Light (Muted) - For comfortable light experience

🛠️ Development & Contributing

GitHub Repository

• Source Code: https://github.com/ortus-boxlang/vscode-boxlang-theme

• Report Issues: GitHub 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

5. Test themes using npm run dev:host

6. Submit a pull request with screenshots

Comments are necessary for any programming language. BoxLang is no different in helping you add code comments in both script and tag syntax. The syntax is the same if you are a Java/Kotlin developer.

Tag Comments

You can use the <!--- and ---> Syntax to comment within a BoxLang template (.bxm). This is similar to HTML comments but adds an extra - to demarcate it as a BoxLang comment.

HTML Comment
<!-- I am an HTML Comment -->

BoxLang Comment
<!---  I am a BoxLang Comment --->

Script Comments

If you are within a class, scripting or in a <bx:script> block, you can use an alternate style for comments. You can leverage // for single-line comments and the following for multi-line comments:

/**
 * Multi-line Javadoc style comment
 *
 * @COLDBOX_CONFIG_FILE The override location of the config file
 * @COLDBOX_APP_ROOT_PATH The location of the app on disk
 * @COLDBOX_APP_KEY The key used in application scope for this application
 * @COLDBOX_APP_MAPPING The application mapping override, only used for Flex/SOAP apps, this is auto-calculated
 * @COLDBOX_FAIL_FAST By default if an app is reiniting and a request hits it, we will fail fast with a message. This can be a boolean indicator or a closure.
 */


/*
  Multi
  Line
  Comments
  are
  great!
*/

// Single-line comment

BxDoc: "Javadoc" style comments

A multi-line block can affect the metadata of a class or function if the opening line contains 2 asterisks. Also, for readability, some people will start each line of the comment with an asterisk. BoxLang will parse out those starting asterisks, but they will not appear in the class or the function metadata.

You can use all the JavaDoc style comments; however, when doing parameters, we omit the verbosity of the @param {name} hint and use the @{name} hint.

/**
 * This is my class hint
 *
 * @author Luis Majano
 * @version 1.0.0
 */
class extends="Base" implements="IHello" singleton{

     /**
      * This is the hint for the function
      *
      * @param1 This is the hint for the param
      * @data The incoming data
      *
      * @throws InvalidException - If the exception is invalid
      *
      * @return A string of data
      */
     function myFunc( string param1, data ){
     }

}

DocBox

We have a tool call DocBox that can generate the documentation off your BoxLang classes, much like JavaDoc.

Please check out the annotating your code section in the DocBox documentation to get a feel for how to document your code: https://docbox.ortusbooks.com/getting-started/annotating-your-code

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

• Take advantage of the modern JVM

• TDD/BDD Fully Tested Source

• Support and adapt to multiple runtimes

• Multi-Parser design to support running different dynamic languages like CFML, Groovy and more.

• Tooling and enhanced IDE

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.

4. InvokeDynamic: BoxLang has a solid core foundation based on the JVM’s InvokeDynamic features. This makes the dynamic language extremely fast, predictable, and adaptable.

5. Java Interoperability: BoxLang is 100% interoperable with Java. You can extend and implement Java objects, use Java annotations, declare classes, import classes, and even write in Java seamlessly. Thanks to InvokeDynamic and our BoxLang DynamicObject core, everything in BoxLang is interoperable with Java.

6. Pure Functions and Closures: BoxLang supports creating and using closures as a functional programming aspect. However, it also supports lambda pure functions 2 without access to the surrounding context, which makes them extremely fast and portable. Functions are first-class citizens in BoxLang. You can define them dynamically, pass them around, and execute them whenever possible, making BoxLang a highly functional language.

7. Event-Driven Language: BoxLang has an internal interception event bus that can extend the language's capabilities or even your applications. You can listen to almost every part of the language, parser, and runtime or collaborate with your custom events.

8. Modular: BoxLang has been designed internally to support the concept of BoxLang modules that can enhance every aspect of the language or your applications built with BoxLang. BoxLang is one of the first languages you can build upon using modules. You can add new built-in functions, templating components, and new/modified functions on existing classes, functionality, Runtime Debugger, and AOP aspects, or you can listen to events within the language.

9. Professional Open-Source: BoxLang is a professional open-source project based on the Apache 2 license. Ortus Solutions supports every aspect of the language, and you can get a BoxLang+ subscription for professional support, extended features, and modular capabilities.

10. Multi-Platform Development: BoxLang has been designed to run on multiple platforms. This allows you to write adaptive code for any Operating System JVM, a servlet container web server, cloud lambda functions, iOS, Android, or even the browser via our web assembly package. BoxLang© builds upon its language core to be deployed on almost any running platform, present or future.

11. Portable, Fluent, Human Scheduled Tasks: BoxLang Scheduled Tasks Framework provides a centralized and portable way to define and manage scheduled tasks on your servers and applications. Source control your tasking with our scheduling DSL.

12. CFML Compatible: BoxLang supports a dual parser and transpiler to execute CFML code natively (maybe more languages later). This means that you can run all your applications written in CFML within BoxLang natively. We also provide tooling to automatically transpile your CFML code to BoxLang.© if you have a + Subscription.

13. Tooling: We provide the core language and several tools to help developers do their job easily and efficiently. We provide a Visual Studio Code extension for the language to provide syntax highlighting, debugger, code insight, code documentation, formatting, LSP integration, and more. Our + subscribers get even more tools like enhanced debuggers, CFML transformers, and more.

14. Ecosystem: Even though BoxLang is a new language, it already has an established ecosystem since every Java and CFML library works with BoxLang. This was our priority when designing BoxLang, and it would automatically be able to integrate and run libraries from the Java and CFML ecosystems. It ships with CommandBox as its package manager, server manager, task manager, and REPL tool. Almost any project in https://central.sonatype.com/ 1 and https://www.forgebox.io should work with BoxLang.

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 CLI tools. 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 compatibility module 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, Into The Box.

🚀 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.

Licenses Available TODAY!

Additionally, we are thrilled to open up support license subscriptions () for BoxLang +/++, offering enterprise-grade support, priority fixes, and exclusive benefits. As an introductory offer, all licenses are available at 50% off for February. In March, with the release of RC2, discounts will adjust to 25% off—scaling down progressively until our official launch at Into The Box 2025 ().

Let me also remind you that our Visionary Licenses will cease to be offered by the end of this month. Visionary licenses are unique for 10 years and 5 years of support. If you are interested in securing a visionary license, please email us at .

Production Tips

We encourage you to pre-compile your applications using our BoxLang compiler for incredibly safe and high-performance deployments since no parsing is involved. Combined with our new , your applications will fly and be highly performant.

Release Notes

New Features

Make sure execution exceptions are propagated to an `exception.log` for all runtimes

Create getHTTPTimeString bif in the CFML Compat Module

Missing bif: createTime()

Improvement

returns 500 status code when hitting the default error page

Allow annotation values of unquoted strings

allow RHS of castas operator to omit quotes

default output to true in Application classes

Disable external DTD validation

Migrate usage of LoggerFactory.getLogger to the internal BoxLang logger classes in the core

BIF and Component abstract objects now have a logger that maps to a `runtime` logger for ease of use

Favor native java methods on a struct if there is a key of that name, but it's not a function

Improve boxpiler selection by using the interface not classes or direct implementations

Bugs

Abort should not fire the `onRequestEnd` method ( or it should fail quietly )

Struct.put Usage Throws Error

BX-ORM: When First Request to Application is a CFC, the application scope is undefined when starting ORMApp attempts to instantiate

numeric key access of struct failing for BigDecimal keys

directoryList does not sort by name

Too many pattern letters: m

Trivial: Typo in error message

thread attribute scope needs to be headlessly accessible

structget() incorrectly returning true with cfml-compat installed

String caster doesn't work on char[] and produces incorrect results for Character[]

class dump template doesn't work with compat module

Access and mutation of native Java unboxed arrays doesn't work

Query objects do not allow complex data when adding columns via `queryAddColumn()` with no data type.

Can't use EMail as a returntype from EMail object

shebang detection not working and skipping execution to the REPL

isValid uuid returns false

Error executing dump template

default string representation of exception object

Dereferencing property on Java class not calling getter

Jakarta servlet removed response.setStatus( int, String ) from API

Typo in exception string for parseDateTime

getDirectoryFromPath breaks when passed a null value

Durations created by `createTimespan` can't be casted to strings

`this` scope can no longer be mutated

final access modifier with explicit static scope on assignment not working

static method access on non-imported identifer not working

boxpiler was defaulting to javaboxpiler internally, remove it, it should be null and seeded later

isSimpleValue returns true on Exception in Compat Mode

QueryParam: SQL Server Unknown Column Type `datetime`

ParseDateTime failure with `hh:nn a` mask - e.g. `03:00 PM`

onRequestEnd() not firing for on class requests

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

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:

📱 Web Applications

• Blog Systems - Complete blog applications with database integration

• Comic Book Reader - File processing and web-based viewing applications

• Calendar Applications - Date/time handling and UI generation

• File Search Tools - Full-text search and indexing systems

• API Integration Examples - REST API consumption and data processing

📊 Data & Integration

• Database Access - MySQL, Derby, and database query examples

• CSV Processing - File parsing and data transformation

• RSS Feed Aggregation - Multi-source data collection and normalization

• JSON Handling - Data serialization and API responses

• PDF Processing - Document generation and manipulation

🔧 Advanced Features

• Java Library Integration - Using external JARs and Maven dependencies

• Module Development - Creating custom BoxLang modules with BIFs

• Async Programming - Background processing and concurrent operations

• Web Scraping - AgentQL integration and data extraction

• AI/ML Integration - Sentiment analysis and machine learning workflows

🎯 Development Patterns

• MVC Applications - Structured web application architecture

• REST APIs - Building and consuming web services

• Template Systems - Dynamic content generation

• Custom Tags - Reusable component development

• CLI Tools - Command-line application examples

🎮 Interactive Playground

Don't forget about - your online coding playground where you can experiment with BoxLang code directly in your browser without any local setup required.

📝 Featured Examples

Some notable examples from the repository include:

Real-World Blog Application

Complete blog system with:

• Database integration ( MySQL/Derby )

• Custom routing and templates

• Administration interface

• Multi-user support

Java Library Integration

Demonstrates how to:

• Include external JAR files

• Use Maven-style dependencies

• Integrate with Java Optional patterns

• Handle complex Java objects

Module Development

Shows how to create:

• Custom Built-In Functions ( BIFs )

• Modular components

• Library packaging

• Distribution and installation

API Development & Consumption

Examples of:

• REST API creation with remote functions

• External API integration ( Jira, AgentQL, Pinecone )

• Data transformation and caching

• Error handling patterns

🔨 Getting Started with Demos

1. Clone the Repository:

2. Browse Categories:

   • webapps/ - Full web applications

   • modules/ - Custom module examples

   • misc/ - Utility scripts and tools

   • Individual demo folders contain README files with setup instructions

3. Try Online First:

   • Visit for immediate experimentation

   • Copy demo code snippets to test concepts

   • No local installation required

🎯 Learning Path Suggestions

Beginners

Start with basic examples in misc/ folder, then explore simple web applications

Web Developers

Focus on webapps/ examples, especially the blog and API demonstrations

Java Developers

Check out Java integration examples and module development patterns

Advanced Users

Explore AI integration, async programming, and complex data processing examples

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.

As developers familiar with CFML or Java, we are all familiar with the writeDump() or System.out.println() style of development. While outputting your application state to the browser or to a file has its place, a debugger offers several benefits over a logging-based debugging approach. Here are just a few of them:

• Add/remove breakpoints as your programming executes instead of having to re-run the request

• Inspect variables at each iteration of a loop

• Create watchers for specific variables and values

• Modify the value of a variable and continue execution

• Step through each method of a call stack to see the different levels of an application

• So much more

Getting started can be daunting if you have never used a debugger before. We have put much effort into making the BoxLang debugger as easy to start as possible. Let’s take a look at how to use it.

Debugging BoxLang Classes & Scripts

Let's say you have a .bxs file. This is BoxLang’s CLI script extension. With a .bxs you can execute your file on the command line just like any other scripting language. Our VS Code extension makes it even easier. We provide a right-click option to run BoxLang files or via the command pallete as well.

You can also run bx files which are BoxLang classes, as long as they have a main() method on them, in the same manner as above:

Once you click the BoxLang: Run Script option. Your program will execute. The debug console will auto-focus and you will see the console output of your program. “Great!” You might say, “But what about debugging! Fair enough! Let’s look at that next.

If you want to debug a script you will need to set a breakpoint. To set a breakpoint simply hover your cursor over the gutter to the left of the file’s line numbers. When you see a red dot appear, “click” and you will set a breakpoint at that line. Now that you have a breakpoint go and ahead and use our right-click BoxLang: Run Script option to kick off a debug session. This time your script will pause at your breakpoint.

Debug Controls

Now that we are debugging, what special actions can we take? We’ll briefly look at 3 features of our debugger: variables, the call stack, and debugger controls.

Variables

The Variables Panel gives you information about the state of your program. You can view and even edit variables by looking at the data presented by this panel. This is where much of the value of the debugger comes from. At every breakpoint you hit you will see an up-to-date snapshot of your application state.

Call Stack

The Call Stack Panel lets you see the entire call stack of your current location in the code. This feature is a little more advanced than the variables panel but can provide vital information that helps you understand the flow of code in your app.

Controls

Finally, we get to the debugger controls. These controls are the unsung hero of every debug session, you’ll use them often as you incorporate the debugger into your workflow.

• Play/Pause - Resume execution if paused/pause execution of a running program.

• Step Over - Move to the next pausable location without moving down the call stack

• Step In - Move into a deeper stackframe if able or Step Over

• Step Out - Move to the parent stack frame

• Stop - Stop debugging

The controls mostly speak for themselves. The best way to get familiar with them is to jump in and play around. After just a few minutes of playing around with them, using them as part of your debug process will become second nature.

Further Debugging

You can also debug your web applications easily by running the BoxLang debugger on either the MiniServer or CommandBox Runtimes:

Conclusion

I hope you will agree that the BoxLang Debugger is a powerful addition to the set of tools we at Ortus have built to help you develop BoxLang applications. Now code some Box!

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!

New Features

Look and execute for Application.bx|cfc when running scripts or classes via CLI execution

We have always wanted even further CLI enhancements for applications built with BoxLang. Now you get it! BoxLang will look for an Application.bx|cfc whenever it executes a template or class and follow the process of application startup, settings, ORM, etc. The full life-cycle of an application but at the CLI level. This will allow you to completely test your web applications with no web server and even build CLI applications with easy application constructs!

New bx-web-support module to support the CLI with web server capabilities. Great for testing, mocking and feature audits.

We have released the bx-web-support module which will give you mocking, testing and auditing capabilities for CLI testing and runners. This means that your CLI applications will look and feel like a real web application with a real web server, but using our mock approaches.

This module is still in it's alpha stages so expect much more development on it.

Module settings should have a deep merge from the configuration file

All module settings in your boxlang.json can now be deeply merged automatically by BoxLang.

Add a new ToString dump template that will take a list of java objects to display them in short hand format

We will be easing the visibility of certain human readable Java classes in our dump templates.

Handle single values in arrayAppend merge=true

A nice feature to support further merging techniques with arrays.

Improvements

dump improvement of UI when using expand/collapse

Show errors in class pseudo constructor in tag context

List utils need to trim all values when converting to arrays

LocalDateTime not showing in dumps as a date/time string, but as a Java Object

Update date/time and instant dump templates to be less verbose and more functional

Allow CF tag islands and template islands to be nested more than one level deep.

Merge CF lexer and grammar for faster parsing and more accurate lexing

Make tag expression parsing smarter

expandPath() must ignore invalid paths, just returning the input

More IO BIFs need to ignore invalid paths

Bugs

script block parsing can be tricked by comments

Lucee allows properties to be anywhere in the pseduoconstructor of a class, not just at the top

flush component only flushes up one buffer, not all the way

Boxlang doesn't parse milliseconds in datetime string

Date "string" doesn't have date time member functions available

Querynew failing with more than one column defined

Regular Expression Syntax not supported

Metadata visitor doesn't support struct annotations with unquoted keys

Hyper module failing

bx-compat cfloop requires "index" when it shouldn't

transaction shouldn't require global DSN

cfproperty tag lucee allows non quoted properties

Class name sensitivity based on provided rather than class found

No reading dump templates due to pathing incorrectly in debug mode

Static support not compatible with CFML

javacast not actually casting as expected

functions in variables scope vs values in variables scope

bx-compat unquoted hashed expressions cause compiler error

serializeJSON errors when serializing a function

Sentinel loop with missing expressions fails

mid() It does not remove characters if the count is more than the length

Cannot invoke "ortus.boxlang.runtime.types.IStruct.putAll(java.util.Map)" because "recipient" is null

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