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

Code Of Conduct

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

• As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.

• Participants will be tolerant of opposing views.

• Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.

• Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions not aligned with this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.

• When interpreting the words and actions of others, participants should always assume good intentions. Emotions cannot be derived from textual representations.

• Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more project maintainers.

Bug Reporting

Please link it to the appropriate issue if you submit a pull request.

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

If you file a bug report, your issue should contain a title, a clear description of the issue, a way to replicate the issue, and any support files we might need to replicate your issue. The goal of a bug report is to make it easy for yourself - and others - to replicate the bug and develop a fix for it. Not all issues that do not contain a way to replicate will be addressed.

Support Questions

If you have questions about usage, professional support, or ideas to bounce off the maintainers, please do not create an issue. Leverage our support channels first.

• Ortus Community Discourse: https://community.ortussolutions.com

• Box Slack Team: https://boxteam.ortussolutions.com

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

Pull Request Guidelines

• The main branch is just a snapshot of the latest stable release. All development should be done in dedicated branches. Do not submit PRs against the main branch. They will be closed.

• All pull requests should be sent against the development branch or the LTS version branch releases/v{version}

• It's OK to have multiple small commits as you work on the PR - GitHub will automatically squash it before merging.

• Make sure all local tests pass before submitting the merge.

• Please make sure all your pull requests have companion tests.

• Please link the Jira issue in your PR title when sending the final PR

Security Vulnerabilities

If you discover a security vulnerability, please email the development team at [email protected]. All security vulnerabilities will be promptly addressed.

JRE Compatibility

Please make sure your code runs on JRE 21+

Financial Contributions

You can support BoxLang and all of our Open Source initiatives at Ortus Solutions by becoming a Patreon. You can also get lots of goodies and services depending on the level of contributions.

• Become a backer or sponsor on Patreon

• One-time donations via PayPal

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/

Discover an extensive collection of demos at https://github.com/ortus-boxlang/bx-demos/. This repository offers a wide range of example projects and code snippets designed to illustrate various programming concepts and techniques.

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. Dive into the collection and start exploring the diverse range of demos available for your learning journey.

Also remember that you have https://try.boxlang.io at your disposal as a coding playground.

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.

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

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

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

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

Migration Guides

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

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.

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.

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

Ubuntu 24.04 LTS based

BoxLang MiniServer with NGINX on Ubuntu 24.04 LTS

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang MiniServer behind NGINX as HTTP Reverse Proxy. Additionally, you can connect to your Virtual Machine to develop and manage it. Review our offer in AWS Marketplace.

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 our offer in AWS Marketplace.

Learn how to deploy Ubuntu-based BoxLang Cloud Servers here.

Windows Server 2019-based

BoxLang MiniServer with IIS on Windows 2019

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang MiniServer behind IIS as an HTTP Reverse Proxy. Additionally, you can connect to your Virtual Machine to develop and manage it. Review our offer in AWS Marketplace.

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). Review our offer in AWS Marketplace.

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

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

The source code for this book is hosted on GitHub: https://github.com/ortus-boxlang/boxlang-docs. 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 - https://www.harvesting.org/. 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 (https://www.harvesting.org/) 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.

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 in-depth guide can be found here: https://commandbox.ortusbooks.com/setup

Requirements

• 256MB+ RAM

• 250MB+ free hard drive space

• Multi-core CPU recommended

• JRE/JDK 21+

Getting Started

We have created a small getting started guide to give you enough skills to move forward with any CommandBox development. You can find it here: https://commandbox.ortusbooks.com/content/getting_started_guide.html

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

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

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

In addition, CSRF Token functionality is now provided via .

New Feature

Global events for Application events

Implement table filter for dbinfo component

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

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

Improvement

Implement Algorithm Argument for RandRange

Set request class loader into thread as context class loader

Retain directories in dynamic class loader

Add nullIsUndefined flag to control how null variables are handled

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

Bug

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

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

Difference in args vs local variables handling

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

cfloop collection with an array throws casting exception

argument collection optional param is null

dot access not chaining to static access

NPE when calling non-existent Java method

Duplicate of cfc instance presenting as struct

Key access in StructMapWrapper not working

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

import name restrictions too strict

Assignment not working on static fields of an imported class

Adding two ints uneccessarily returns a long

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

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

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

New configuration: validClassExtensions to determine which class extensions to work with

New security configuration section for disallowing: BIFS, Components, Imports

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

Improvement

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

Consolidate CastAttempt and Attempt into a hierarchy

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

Bug

Import nested classes

Java static funcitons not behaving as expected

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

QueryColumnType doesn't handle "idstamp" (mssql)

static scope in application.cfc not initialized before psuedoConstructor runs

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

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

Tag expressions not parsing inside template island inside braces

duplicate() doesn't work on empty structs

randrange() not inclusive of upper bound

array.find - can't cast closure to string

Dynamic Language

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

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

ByteCode

BoxLang compiles to Java Byte code using two provided algorithms.

Debug JIT Algorithm

Production JIT Algorithm

Code - Execute - Refresh - Repeat

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

Code Portability

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

Java Interop

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

JSR-223

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

Multi-Runtime

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

Running from the Command Line

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

An Example Scripting File

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

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

BoxLang REPL

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

Keep reading our guides as you learn more about BoxLang.

To run BoxLang in your GitHub Actions workflow, you need to add a step to your workflow file to set up and execute BoxLang. Below is an example of how you can use the action to run BoxLang with default settings:

This setup installs BoxLang, optionally installs modules, and runs a BoxLang script within your repository. Adjust the version and modules as needed.

Inputs

The following are all the different input variables you can use with the action, allowing you to set up BoxLang in your GitHub Actions workflow.

Usage Examples

Simple usage:

With Specific Modules:

Install a specific version of BoxLang:

Here is another one:

System Requirements

This action will automatically install the following system packages if they are not already available:

• openjdk-21-jre (or equivalent) - Java Runtime Environment for 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:

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

Available Platforms:

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

• Microsoft Azure - Ubuntu Virtual Machines

• Google Cloud Platform - Coming Soon

Key Features & Advantages

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

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

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

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

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

1. Launch an EC2 instance within your desired region.

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

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

Azure provides Virtual Machines (VMs) for hosting BoxLang:

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

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

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

Google Cloud (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.

In this section of the docs, you will find a collection of tools, IDE integrations, and much more to assist you in your BoxLang adventures.

BoxLang IDE

We have an official first-party extension for Visual Studio Code. You can find it in the Visual Studio Code. It also has its documentation website:

Features at a Glance

• Language server integration

  • Inline documentation

  • Language hints

  • Type information

• Mini BoxLang web server for quick development/testing

• BoxLang version manager

• BoxLang Agentic Coding @boxlang

• Code Highlights and Introspection for supported grammars: Java, HTML, CSS, SQL, CFML

• So much more.

BoxLang Monaco Editor

Monaco Editor language support for BoxLang - providing syntax highlighting, IntelliSense, and custom themes for BoxLang development.

CLI Tools

We have a collection of CLI tools available to every OS installation:

Syntax Highlighters

Check out our syntax highlighters page so you can leverage some of them in your applications.

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 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 for boxlang runner.

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:

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.

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

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

BL-603 Implement timeout for HTTP requests

BL-604 Multi-part request support in HTTP

Improvement

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

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

BL-590 Make include case insensitive

BL-596 Enhance metadata visitor to process extends

BL-597 add fieldNames key to form scope

BL-599 Auto casting for URI and URL classes to string

BL-600 Handle bad gateways in HTTP component

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

BL-602 autocast InetSocketAddress to string

Bug

BL-584 Fix for overeager escaping of quantifier sequences in REFind

BL-585 High order closures creating incorrect AST when parsing

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

BL-588 Module settings no longer overriding after deep merge function added

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

BL-592 Can't assign to List due to incorrect validation in referencer

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

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

BL-595 showUDFs not cascading down in dump levels

BL-598 using cfcookie should update cookie scope

BL-606 Fix argument order for FileUpload

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 installation methods.

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.

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!

So you’ve installed CommandBox 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:

server start cfengine=boxlang 
  javaVersion=openjdk21_jdk 
  JVMArgs='-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8888'

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

{
  "JVM": {
    "args": "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8888",
    "javaVersion": "openjdk21_jdk"
  }
}

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:

{
  "configurations": [
    {
      "name": "Debug CommandBox",
      "type": "boxlang",
      "request": "attach",
       // make sure this is the same value you configured your server with            
      "serverPort": "8888"
    }
  ]
}

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!

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

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:

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 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 for boxlang runner.

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

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

Scan all your models for missing BIFs and Components

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

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

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.

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:

// Logging Settings for the runtime
"logging": {
	// The location of the log files the runtime will produce
	"logsDirectory": "${boxlang-home}/logs",
	// The maximum number of days to keep log files before rotation
	// Default is 90 days or 3 months
	// Set to 0 to never rotate
	"maxLogDays": 90,
	// The maximum file size for a single log file before rotation
	// You can use the following suffixes: KB, MB, GB
	// Default is 100MB
	"maxFileSize": "100MB",
	// The total cap size of all log files before rotation
	// You can use the following suffixes: KB, MB, GB
	// Default is 5GB
	"totalCapSize": "5GB",
	// The root logger level
	// Valid values are in order of severity: ERROR, WARN, INFO, DEBUG, TRACE, OFF
	// If the runtime is in Debug mode, this will be set to DEBUG
	"rootLevel": "WARN",
	// Default Encoder for file appenders.
	// The available options are "text" and "json"
	"defaultEncoder": "text",
	// A collection of pre-defined loggers and their configurations
	"loggers": {
		// The runtime main and default log
		"runtime": {
			// Valid values are in order of severity: ERROR, WARN, INFO, DEBUG, TRACE, OFF
			// Leave out if it should inherit from the root logger
			//"level": "WARN",
			// Valid values are: "file", "console",
			// Coming soon: "smtp", "socket", "db", "syslog" or "java class name"
			// Please note that we only use Rolling File Appenders
			"appender": "file",
			// Use the defaults from the runtime
			"appenderArguments": {},
			// The available options are "text" and "json"
			"encoder": "text",
			// Additive logging: true means that this logger will inherit the appenders from the root logger
			// If false, it will only use the appenders defined in this logger
			"additive": true
		},
		// The modules log
		"modules": {
			// Valid values are in order of severity: ERROR, WARN, INFO, DEBUG, TRACE, OFF
			// Leave out if it should inherit from the root logger
			//"level": "WARN",
			// Valid values are: "file", "console",
			// Coming soon: "smtp", "socket", "db", "syslog" or "java class name"
			// Please note that we only use Rolling File Appenders
			"appender": "file",
			// Use the defaults from the runtime
			"appenderArguments": {},
			// The available options are "text" and "json"
			"encoder": "text",
			// Additive logging: true means that this logger will inherit the appenders from the root logger
			// If false, it will only use the appenders defined in this logger
			"additive": true
		},
		// All applications will use this logger
		"application": {
			// Valid values are in order of severity: ERROR, WARN, INFO, DEBUG, TRACE, OFF
			// Leave out if it should inherit from the root logger
			"level": "TRACE",
			// Valid values are: "file", "console",
			// Coming soon: "smtp", "socket", "db", "syslog" or "java class name"
			// Please note that we only use Rolling File Appenders
			"appender": "file",
			// Use the defaults from the runtime
			"appenderArguments": {},
			// The available options are "text" and "json"
			"encoder": "text",
			// Additive logging: true means that this logger will inherit the appenders from the root logger
			// If false, it will only use the appenders defined in this logger
			"additive": true
		},
		// All scheduled tasks logging
		"scheduler": {
			// Valid values are in order of severity: ERROR, WARN, INFO, DEBUG, TRACE, OFF
			// Leave out if it should inherit from the root logger
			"level": "INFO",
			// Valid values are: "file", "console",
			// Coming soon: "smtp", "socket", "db", "syslog" or "java class name"
			// Please note that we only use Rolling File Appenders
			"appender": "file",
			// Use the defaults from the runtime
			"appenderArguments": {},
			// The available options are "text" and "json"
			"encoder": "text",
			// Additive logging: true means that this logger will inherit the appenders from the root logger
			// If false, it will only use the appenders defined in this logger
			"additive": true
		}
	}
},

JSON Anyone?

We have added support for JSON Lines 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 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

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

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.

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.

task = new Task();
invoke( task, "setFoo", { foo : "bar" } );
result = invoke( task, "getFoo" );

println( result );

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:

class inject hello="word"{

	property foo;
	property firstName;
	property lastName;
	property numeric age default=1;

	function main( args = {} ){
		test = new Person();
		println( test.toJson() )

		println( this.$bx.getMeta().keyArray() )
		println( this.$bx.getMeta().annotations )
	}

	function onMissingMethod( missingMethodName, missingMethodArgs ){
		println( "Missing method: " & missingMethodName );
		println( "missingMethodArgs: " & missingMethodArgs.toString() );
	}

}

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:

MiniServer Debugging

CommandBox Debugging

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!

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.

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

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

You can find all our published images and tags here: https://hub.docker.com/r/ortussolutions/boxlang. Please see the Environment Variables section for more information on how to configure the images for runtime and deployment.

• CLI Images :

• MiniServer Images :

We also have an experimental image for the BoxLang MiniServer with Nginx included.

• MiniServer with Nginx :

CLI Images

This image contains the BoxLang CLI, which allows you to run BoxLang scripts, CLI applications, commands, schedulers and any OS integrations.

• ortussolutions/boxlang:cli - The latest BoxLang CLI image based on Debian Linux

• ortussolutions/boxlang:cli-alpine - The latest snapshot of the BoxLang CLI image based on Alpine Linux

• ortussolutions/boxlang:cli-snapshot - The latest snapshot of the BoxLang CLI image

• ortussolutions/boxlang:cli-alpine-snapshot - The latest snapshot of the BoxLang CLI image on Alpine Linux

MiniServer Images

This image contains the BoxLang MiniServer, which is a lightweight web server that can run BoxLang applications, APIs and services. It is designed to be fast, lightweight, and easy to use.

• ortussolutions/boxlang:miniserver - The latest BoxLang MiniServer image based on Debian Linux

• ortussolutions/boxlang:miniserver-alpine - The latest snapshot of the BoxLang MiniServer image based on Alpine Linux

• ortussolutions/boxlang:miniserver-snapshot - The latest snapshot of the BoxLang MiniServer image

• ortussolutions/boxlang:miniserver-alpine-snapshot - The latest snapshot of the BoxLang MiniServer image on Alpine Linux

The MiniServer will load the /app as the root directory of the server, so you can mount your BoxLang applications and services there. The MiniServer will also automatically load the index.bxm file as the default file to serve. Rewrites are enabled by default, and you can configure them using the REWRITES_FILE environment variable.

Health Check

The Docker images include a health check that will ping the MiniServer's root endpoint to ensure it is running. The health check can be configured using the HEALTHCHECK_URI environment variable, which defaults to http://127.0.1:${PORT}/. The health check will run on an interval of 20 seconds, timeout of 30 seconds and 15 retries before marking the container as unhealthy.

Modules

The image has a module installer built in: /usr/local/bin/install-bx-module which can be used via the BOXLANG_MODULES env variable. If it detects it, then it will try to download an install those modules into the runtime's home. We recommend you do this by warming up the server first.

Example:

Environment Variables

The following environment variables can be used to configure the BoxLang Docker images:

• BOXLANG_CONFIG_PATH - The path to the BoxLang configuration file. Default: /root/.boxlang/config/boxlang.json

• BOXLANG_DEBUG - Enable debugging. Default: false

• BOXLANG_HOME - The home directory of the BoxLang installation. Default: /root/.boxlang

• BOXLANG_HOST - The host the MiniServer will listen on. Default: 0.0.0.0

• BOXLANG_MODULES - A comma-separated list of modules to install. Default: ``. Example: bx-compat-cfml,bx-esapi,bx-mysql

• BOXLANG_PORT - The port the MiniServer will listen on. Default: 8080

• DEBUG - Enable debug mode. Default: false

• JAVA_OPTS - Java options for the MiniServer. Default is -Djava.awt.headless=true

• HEALTHCHECK_URI - The URI for the health check endpoint. Default: http://127.0.0.1:${PORT}/

• HOST - The host the MiniServer will listen on. Default: 0.0.0.0

• MAX_MEMORY:512m - The maximum memory allocated to the BoxLang process. Default: -Xmx512m

• MIN_MEMORY:512m - The minimum memory allocated to the BoxLang process. Default: -Xms512m

• PORT - The port the MiniServer will listen on. Default: 8080

• REWRITES - Enable URL rewrites. Default: true

• REWRITES_FILE - The file containing the URL rewrites. Default: index.bxm

BoxLang Environment Variables

Please note that BoxLang has the capacity to override any configuration setting via environment variables using the BOXLANG_ prefix. Click here for more information: https://boxlang.ortusbooks.com/getting-started/configuration#environment-variable-substitution

Example:

Experimental: MiniServer with Nginx

This image combines the BoxLang MiniServer with Nginx to provide a lightweight web server that can serve static files and proxy requests to the MiniServer. This is an experimental image and is not recommended for production use just yet. Here are the available environment variables:

• NGINX_PORT - The port Nginx will listen on. Default: 80

• NGINX_SSL_PORT - The SSL port Nginx will listen on. Default: 443

Nginx has been configured to do rewrites for BoxLang applications, fine-tuned for production use and a self-signed SSL certificate is included. You can mount your own SSL certificate and key to the /etc/nginx/ssl directory.

What is nothingness? Is there nothingness only in outer space? If a tree falls in the forest and nobody listens, does it make a sound? Starting to see the point? Does nothing really mean nothing? To be or not to be? OK, I think we are going on a philosophical tangent, so let's get back to our geekiness:

null is Java's way to refer to "nothingness.", something that does not exist and has no value.

Full-Null Support

Full null support is the default in BoxLang, meaning you can use the null keyword and get real null values from databases or external services. Note that null is a reserved word so can't be used for variable names.

Note that if you are using the compat module then full null support is disabled unless you change the module settings for compat to enable it. You can do this programmatically via the Application.bx file, which can be used when building web applications. You can learn more . In reality, you still could simulate null without full null support, and sometimes you get an empty string, sometimes a full Java null. So basically, the nonfull null support is a partial null support, which makes it hard for developers. So as a rule of thumb, we always recommend checking for nullness no matter WHAT!

Checking For Nullness

Use the isNull() or isDefined() methods to evaluate for nothingness.

Also, remember that you can use the to test for null and an operator and expression.

Creating Nulls

You can create nulls in different ways in BoxLang. Let's explore these:

In Practice

If you have three eggs and eat three eggs, then you might think you have "nothing," but in terms of eggs, you have "0". Zero is something, it’s a number, and it’s not nothing.

If you’re working with words and have a string like "hello" then delete the "h", "e", "l"s, and "o" you might think you’d end up with nothing, but you have "" which is an empty string. It’s still something.

Null in BoxLang is usually encountered when you ask for something that doesn’t exist. When looking at arrays, for instance, we created a list with five elements then asked BoxLang to give us the sixth element of that list. There is no sixth element, so BoxLang gave us null. It isn’t that there’s a blank in that sixth spot (""), it’s not a number 0, it’s nothingness – null.

Examples

Also note that if a function returns nothing, it will be the same as returning null.

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.

Bugs

BL-1353 BoxRunner fails on some input args

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

Ubuntu 24.04 LTS based

BoxLang MiniServer with NGINX on Ubuntu 24.04 LTS

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang MiniServer behind NGINX as an HTTP Reverse Proxy. Additionally, you can connect to your Virtual Machine to develop and manage it. Review our offer in Azure Marketplace.

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 our offer in the Azure Marketplace.

Learn how to deploy Ubuntu-based BoxLang Cloud Servers here.

Windows Server 2019-based

BoxLang MiniServer with IIS on Windows 2019

Run BoxLang applications, scheduled tasks, scripting, CFML applications, and more with BoxLang MiniServer behind IIS as an HTTP Reverse Proxy. Additionally, you can connect to your Virtual Machine to develop and manage it. Review our offer in Azure Marketplace.

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). Review our offer in Azure Marketplace.

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

🚀 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 (https://www.boxlang.io/plans) 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 (www.intothebox.org).

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 [email protected].

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 trusted cache settings, your applications will fly and be highly performant.

Release Notes

New Features

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

BL-1070 Create getHTTPTimeString bif in the CFML Compat Module

BL-1071 Missing bif: createTime()

Improvement

BL-1020 returns 500 status code when hitting the default error page

BL-1027 Allow annotation values of unquoted strings

BL-1028 allow RHS of castas operator to omit quotes

BL-1029 default output to true in Application classes

BL-1034 Disable external DTD validation

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

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

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

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

Bugs

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

BL-1008 Struct.put Usage Throws Error

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

BL-1025 numeric key access of struct failing for BigDecimal keys

BL-1030 directoryList does not sort by name

BL-1031 Too many pattern letters: m

BL-1032 Trivial: Typo in error message

BL-1033 thread attribute scope needs to be headlessly accessible

BL-1035 structget() incorrectly returning true with cfml-compat installed

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

BL-1038 class dump template doesn't work with compat module

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

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

BL-1041 Can't use EMail as a returntype from EMail object

BL-1043 shebang detection not working and skipping execution to the REPL

BL-1044 isValid uuid returns false

BL-1045 Error executing dump template

BL-1047 default string representation of exception object

BL-1048 Dereferencing property on Java class not calling getter

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

BL-1051 Typo in exception string for parseDateTime

BL-1053 getDirectoryFromPath breaks when passed a null value

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

BL-1058 `this` scope can no longer be mutated

BL-1059 final access modifier with explicit static scope on assignment not working

BL-1060 static method access on non-imported identifer not working

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

BL-1066 isSimpleValue returns true on Exception in Compat Mode

BL-1068 QueryParam: SQL Server Unknown Column Type `datetime`

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

BL-1075 onRequestEnd() not firing for on class requests

We love Chromebooks, so this guide is for those who want to run and develop BoxLang applications using Intel-based or ARM-based Chromebooks. We will install all the prerequisites, BoxLang, and VSCode to use the BoxLang IDE and create our first application.

Requirements

• 4GB RAM Chromebook minimum

• Linux Developer Environment

• JDK 21+

Linux Environment

Chromebooks are great as they allow you to install a Debian Linux container alongside your OS. You can do so easily by opening Settings > Advanced > Developers and installing the Linux environment. Go through the wizard, and voila! Debian Linux will be installed alongside your Chrome OS.

Terminal

You will be interacting with the Linux installation via the Terminal application.

Once you open the terminal, you can click on the Penguin tab, and it will open the Linux terminal.

Installing Pre-Requisites

Let's begin by installing all pre-requisites first:

# Let's update the OS first
sudo apt-get update
sudo apt-get full-upgrade

# Now, some tooling
sudo apt-get install zip unzip curl git gnome-keyring

Installing Java

You can download the OpenJDK 21 For your current architecture from here: https://adoptium.net/temurin/releases/?os=linux

• ARM - https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.3%2B9/OpenJDK21U-jdk_aarch64_linux_hotspot_21.0.3_9.tar.gz

• x64 - https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.3%2B9/OpenJDK21U-jdk_x64_linux_hotspot_21.0.3_9.tar.gz

You can use the following in your CLI to do it easier:

wget {url from above}

# I have an ARM processor
wget 
https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.3%2B9/OpenJDK21U-jdk_aarch64_linux_hotspot_21.0.3_9.tar.gz

# Gunzip it
gunzip OpenJDK21U-jdk_aarch64_linux_hotspot_21.0.3_9.tar.gz
# Untar it
tar -xvf OpenJDK21U-jdk_aarch64_linux_hotspot_21.0.3_9.tar
# Move it to the /usr/lib/jvm folder
mkdir /usr/lib/jvm
mv jdk-21.0.3+9 /usr/lib/jvm/

Now add the JAVA_HOME and the path to the jvm in your PATH using your bash profile

edit .bashrc

export JAVA_HOME=/usr/lib/jvm/jdk-21.0.3+9
export PATH=$PATH:/usr/lib/jvm/jdk-21.0.3+9/bin

We also need to add it to the sudo profile.

Type sudo visudo and add :/usr/lib/jvm/jdk-21.0.3+9/bin to the end of

Defaults secure_path="other/items/"

Once you add this to your bash profile, either source your shell or type bash or close and startup again

# Source your shell
$ source .bashrc

$ java -version
openjdk version "21.0.3" 2024-04-16 LTS
OpenJDK Runtime Environment Temurin-21.0.3+9 (build 21.0.3+9-Debian-LTS)
OpenJDK 64-Bit Server VM Temurin-21.0.3+9 (build 21.0.3+9-Debian-LTS, mixed mode, sharing)

Installing BoxLang

This is the easy part, just type the following command:

sudo /bin/bash -c "$(curl -fsSL https://downloads.ortussolutions.com/ortussolutions/boxlang/install-boxlang.sh)"

This will run the BoxLang installer. Once you are done, just type boxlang and boom! We have BoxLang installed!

This opens the REPL and you can start coding away, running BoxLang files, starting servers and so much more.

VSCode BoxLang

Now that we have BoxLang installed, let's get VSCode so you can use this awesome editor for BoxLang coding!

Choose the debian according to your processor and download the package. If you are unsure about your Chromebook's processor, type dpkg --print-architecture in the Linux terminal for verification. Then double click it and run the installer. Once done, you will have a new icon in your apps called Visual Studio Code. Click it and open it.

Now go to the Extensions Marketplace and search for BoxLang. Then install the extension

Now we are cooking. Create a file using the editor and call it Hello.bx

class{

    function main( args = [] ){
    
        println( "Hello from Chromebook land and BoxLang on #now()#" )
    
    }

}

Now right-click on the editor and say BoxLang: Run File

Hello from Chromebook land and BoxLang on {ts '2024-05-23 18:27:33'}

You have coded your first BoxLang class and ran it! Great job! Let's make it harder now and start a web application. Create a file and call it index.bxm , these are templating files like HTML but spiced up with BoxLang!

<bx:output>
Hello from Chromebook land #now()#
</bx:output>

This uses the <bx:output> component to produce output on the website. Then we reuse the now() built-in function to spit out the date. You can find all about our templating syntax in the language section. Now let's run our BoxLang MiniServer! Open a command palette in VSCode and search for BoxLang

Now click the Run Web Server. You will get the following in the debug console:

+ Starting BoxLang Server...
- Web Root: /home/lmajano/Sites/temp
- Host: localhost
- Port: 8080
- Debug: false
- Config Path: null
- Server Home: null
+ Starting BoxLang Runtime...
+ Runtime Started in 2043ms
+ BoxLang MiniServer started in 2135ms
+ BoxLang MiniServer started at: http://localhost:8080
Press Ctrl+C to stop the server.

It will open the browser for you as well:

You have now created your very first BoxLang web application. Good for you! Now keep exploring the language syntax and framework so you can now take it to the next level! Enjoy!

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

New Features

Phase I : Performance improvements for grammar and parser validation

We have been working with an amazing ANTLR expert: Jim Idle, and we have been able now after several months of hard work to merge in a complete update to our parsers. This has a massive performance increase between 5-10 times more performant than before. However, we are still not those, we have three more performance phases coming up!

Support numeric literal separators in source code

We’ve added a small, but useful syntax to our BoxLang parser that comes from multiple other languages. Numeric placeholders allow you to place underscore characters (_) inside of a numeric literal for readability. Take a number like this

That’s 1 billion. Or was it 1 million? Or maybe it was 100 million… pauses to re-count. With numeric place holders, your code can look like this:

Ahh, so it was 1 billion! There’s no rules on where you can place the underscores, so long as they are INSIDE the number and not leading or trailing. Heck, this is valid (though pointless):

You can also place numeric separators in decimals

and in the exponent of scientific notation

These underscores are simply thrown away at compile time. They are not represented in the bytecode and will not appear anywhere in your running app. They are purely for readability in your source code.

Add static assignment modifier

You can now use the static assignment modifier in your code:

which is sugar for

and validate at runtime there is actually a static scope, or throw an exception.

Add final modifier to classes

You can now use the final modifier in your classes

which is sugar for:

This means that your classes will not be able to be inherited from.

final modifier for UDFs

Your UDFs can now also be declared as final

which will set the function as final into the scope it gets registered into. Any additional function declarations with the same OR ATTEMPTS TO SET A VARIABLE OF THAT NAME will result in an error.

Add final assignment modifier for variables

You can now add final assignment modifers to variables in your code:

this, of course, can be used with other modifiers

The only 2 modifiers that can’t be used together are var and static since they represent different scopes.

When a variable is declared as final, the scope it is being set into will track a list of keys that are designated as final, and will prevent those keys from being modified in the future.

This is ONLY a feature of scopes. Structs and other struct-like container will not have a final concept.

The following example

cannot be mutated OR re-assigned.

You can see the Set of final keys for a scope via the meta object

You can also remove keys from the set to make a variable no longer final.

DynamicInterop now filters non-callable methods when invoking and matching thus accelerating lookups considerably

This is a major update to our dynamic invocation with Java interop. We know only look at callable methods, where as before we looked at every single method on Java classes. This is a significant boost in performance when doing invocations and well, it also fixes a bug on ambiguity between same named methods with different visibility scopes. Relax and ride the lightning ⚡

Zip Utility & compress(), extract(), isZipFile() bifs

BoxLang now speaks Zip language. We have added zip and gzip capabilities to the core. This will allow us to leverage compression and extraction for modular activites, jar installations, logging, and much more. We have also created the following BIFS available to you:

• compress( format, source, destination, [includeBaseFolder=true], overwrite=false ) - Compress a source to a destination using available compression formats.

• extract( format, source, destination, [overwrite=false], [recurse=true], [filter], [entryPaths] ) - Extract a zip/gzip archive to a destination with nice options.

• isZipFile( filepath ) : Determines if the passed file can be treated as a zip archive.

We support the following formats:

• zip

• gzip

More formats will be available for our +/++ subscribers.

Please note also that the filter arguments can be the following:

• A valid regular expression string: ".*\.txt"

• A BoxLang closure or lambda (name) => name.endsWith(".txt")

  • Receives the full path of the entry

• A Java Predicate: (entry) -> entry.getName().endsWith(".txt")

  • Receives the ZipEntry object

In our next betas we will have a the Zip component which will allow you to do the following:

• Compress Files

• Extract Files

• List File Entries

• Delete File Entries

• Read File Entries

• Read Binary File Entries

• Much More.

java.math.BigInteger caster

We had a BigDecimal caster, now we have a BigInteger caster. Not only that, we can correctly coerce Java interop calls for BigDecimal and BigInteger.

Improvements

Allow the incorrect foo..bar syntax that Adobe allows for

Cache sets() and getOrSets() does not accept duration in seconds alongside Duration objects.

Enhance ClassMetadataVisitor

Enhance feature audit to track QoQ separate

Validate var outside of a function

Support Adob'e loose comma parsing in their generic tag-in-script syntax

Enhance errors for identifiers starting with numbers

File And Directory BIFs to auto-expand received paths

Support variable starting with number

Bugs

Compatible encryption with lucee/acf

replace() and replaceNoCase() should accept "one" not "once" for the scope

tag comments not parsing inside output tag in template parsers

parsing fails with extra whitespace in closing output tag

<cfset and <bx:set fail if not followed by a space

Debugger breakpoints not working regression

BoxLang Error is not readable

Tag island Templating outputs in unexpected order

BoxLang Betas are released weekly. This is our third beta marker. Here are the release notes.

New Features

Implement query cache ability

Thanks to our enterprise cache engine and aggregator built into BoxLang, you can now use it to cache queries via its options configuration structure using cfquery or queryExecute. Here are the query caching properties you can use:

• cache:boolean - To turn on caching, this must be true. The default is false

• cacheTimeout:timespan - Optional timeout of the query in the cache. By default, is uses whatever the default timeout of items the cache has been configured with.

• cacheLastAcccessTimeout:timespan - Optional last access or idle timeout of the query in the cache. By default, is uses whatever the default timeout of items the cache has been configured with. This means that if this query is NOT used or requested in this timespan, it will be marked for eviction.

• cacheProvider:string - The name of the cache provider to store the queries. By default, we use the DEFAULT cache in BoxLang.

By default, queries will use , which has default timeouts and lastAccessTimeout values set.

To specify a custom caching provider, you can use the cacheProvider query option:

To specify custom cache entry timeouts, use cacheTimeout or cacheLastAccessTimeout:

Metadata

All query metadata will also have the cache information available to you as well. So you if get dump the query metadata you will see a ton of debugging information about the query:

Interacting With The Cache

Please note that this leverages the BoxLang cache. This means you have full access to the cache provider and you can interrogate it for queries, clear all of them, or clear one of them. The default prefix used for all cached queries is: BL_QUERY

coerce java SAMs from BoxLang function interfaces

This is another major milestone in the Java interop features of BoxLang. This allows us to coerce any BoxLang Lambda/Closure/UDF or even Classes to ANY, yes, ANY Java Functional Interface or Java SAM (Single Abstract Method Interface).

AsyncService support for Virtual Thread Executors (create/manage)

Virtual Threads are now available to BoxLang via executors. You can choose the new VIRTUAL executor for schedulers or when creating schedulers via our AsyncService. This will treat all tasks and schedules to use virtual threads.

More entry points to access this executor will be provided in the coming betas, alongside our very own runAsync() and the ability to create virtual threads as well.

Bifs for module info: getModuleList() getModuleInfo( module )

As more modules are being developed for BoxLang, you now have the ability to know which modules have been loaded and activated in the language. As well as specific information about a module if needed. This is great for inter-dependencies and checking if modules have loaded from BoxLang.

Dumping of Java Classes now includes a dump of the `toString()` value to visualize values better

This is a developer eye-candy, so when you dump any Java class, you can actually see the value of the class instance data via the toString() method.

New dump template for BL Functions

The dumping of BoxLang Functions (Closures, Lambdas, UDFs), either standalone or from a class, has great visibility now. You can see even the class used to generate the function, the function annotations, and much more.

Allow the createDynamicProxy bif to support the request class loader so it can load classes from loaded libraries in the application.bx, runtime and more.

If you use createDynamicProxy() to make a BoxLang class look like a Java class, you can continue to do so now, but it accounts for all class loaders in the application. If you come from a CFML engine, this is impossible and is always a pain and limitation.

In BoxLang, your context matters. So depending on where you create the dynamic proxy, it will account for the surrounding class loaders to be able to create the appropriate Java proxies.

New Script Binaries for bxCFTranspiler, bxCompiler, bxFeatureAudit tools in the distribution bin folder

We have introduced Windows and Mac/Linux binaries for running several CLI tools. You no longer need to refer to the docs with extra-long options. You can now use the provided binaries to call the appropriate CLI tool.

If you use the quick installer, all these binaries will be installed for you.

Improvements

Refactor JDBC connection retrieval out of the QueryOptions class

Dynamic method matching discovery algorithms updated to do 2 pass algorithm: exact, loose coercion matching

Improvement of cache service and cache provider methods for easier boxlang interactions

Refactored the dump css to `resources/dump/html/Dump.css`

Migrate dynamic proxies to native java implementation from the JDK

passing the session id to the onsessionstart listener

Give better warnings if the sessionStorage is not a valid string

Bug

attributecollection not handled properly on cfthrow

Left in system out calls that need to be removed

JSR ScriptEngine starting runtime without debug flag if passed

Creating a default cache was not setting the right name and a "default" already registered exception was being thrown

Default argument values not always checked for type

Implements missing from Box Class metadata

Static Scope missing from metadata

BoxLang is a dynamic language that is fluent with a low verbosity syntax. It will feel like a very lean Java syntax. Check out our quick if you are a Java/Kotlin/Python/PHP/Ruby/CFML/Rust developer, this will give you a first-hand look at the major semantics of the language.

Syntax Files

BoxLang can be written in either templates, scripts, or classes. You will write one or more instructions in a file (.bx, .bxs, .bxm), then run the file through a BoxLang engine or Command Line Interpreter like our REPL.

• bx - A BoxLang class

• bxs - BoxLang scripting file, for a-la-carte scripting

• bxm - BoxLang markup file, tag syntax is the default and used for creating rich views and templating

Implicit Behavior

BoxLang also gives you a pre-set of defined headless and available to you in any file in which you write your code. These components and functions allow you to extend the typical language constructs with many modern capabilities, from database interaction to PDF generation.

Also, note that you can use all the BoxLang types naturally with no imports:

• Structs - (Maps)

• Arrays - (Starting with an index of 1, not 0)

• Strings

• Dates

• Numerics (Floats, shorts, integers, longs, etc)

• XML

• Queries

• Functions

Exploring Behavior

Let's start by exploring some behavior in these types of files. Ensure you are using the Write the code; remember you can execute any BoxLang file within your editor by right-clicking the file and saying "BoxLang: Run File"

Scripting

Let's write a simple scripting file that declares and uses a few boxlang types, and then you can print them on the console. You can run the script via your REPL or via

Now you can run it in the REPL: boxlang myscript.bxs

Templating

I can also use the templating language and build this in an HTML-enabled application.