BoxLang 1.5.0 has landed, and it's packed with features that will transform how you build modern applications. This isn't just another incremental update—we've reimagined performance from the ground up, making BoxLang faster, smarter, and more scalable than ever before.

From lightning-fast serverless deployments to breakthrough parallel processing capabilities, BoxLang 1.5.0 represents weeks of engineering focused on one goal: making your applications perform better while keeping your code simple and maintainable.

You can find our full release notes here: https://boxlang.ortusbooks.com/readme/release-history/1.5.0

🚀 What's New at a Glance

• 🏗️ AWS Lambda Runtime Revolution - Class caching, connection pooling, and convention-based URL to Class routing
• ⚡ Virtual Threads for Parallel Operations - Leverage Java's virtual threads across all parallel BIF operations
• 📊 Enhanced Database Operations - Multiple SQL statements, better parameter handling, and metadata capture
• 🔗 Improved Java Interoperability - Better method resolution and primitive type handling
• 🛡️ Security & Reliability - Enhanced file upload security and memory leak prevention

---

🏗️ AWS Lambda Gets a Major Performance Boost

If you're running BoxLang on AWS Lambda, this release is a game-changer. We've completely reimagined how BoxLang performs in serverless environments.

Lightning-Fast Cold Starts with Class Caching

BoxLang now caches compiled lambda classes, eliminating expensive recompilations on subsequent invocations. In our tests, this reduced cold start times by up to 70% for complex applications.

// Your existing lambda handlers automatically benefit from class caching
function handler( event, context ) {
    // Compiled classes are cached automatically - no code changes needed!
    return {
        "statusCode" : 200,
        "body" : serializeJSON( processEvent( event ) )
    };
}

Convention-Based Multi-Function Lambdas

Building multi-endpoint APIs just got incredibly simple with our new convention-based routing:

// URL: /products -> Products.bx
// URL: /home-savings -> HomeSavings.bx  
// URL: /user-profile -> UserProfile.bx

// Products.bx - handles /products automatically
function handler( event, context ) {
    return {
        "statusCode" : 200,
        "body" : getProductCatalog()
    };
}

Configurable Connection Pooling

Fine-tune your Lambda performance with the new BOXLANG_LAMBDA_CONNECTION_POOL_SIZE environment variable. Perfect for applications with varying database load patterns.

⚡ Virtual Threads: The Future of Parallel Processing

Java's virtual threads are here, and BoxLang makes them incredibly easy to use. Every parallel BIF now supports virtual threads, giving you massive scalability improvements with zero complexity. Over 27 different BIFs now support virtual threads.

Before and After: A Real-World Example

Let's say you're processing a large dataset with API calls:

// Before: Limited by platform threads
results = arrayMap( largeDataset, ( item ) => {
    return callExternalAPI( item ); // I/O bound operation
}, 10 ); // Limited to 10 platform threads

// After: Virtually unlimited concurrency
results = arrayMap( largeDataset, ( item ) => {
    return callExternalAPI( item ); // Same operation
}, true, true ); // Auto threads + virtual = thousands of concurrent operations!

Performance That Scales

Virtual threads use significantly less memory than traditional platform threads and can handle thousands of concurrent operations without thread pool exhaustion. Perfect for:

• API integrations processing hundreds of endpoints
• Data transformations on large datasets
• I/O-heavy operations like file processing or database calls

All parallel BIFs support virtual threads: arrayMap(), listFilter(), queryEach(), structEvery(), and many more!

---

📊 Database Operations Get Smarter

Multiple SQL Statements in One Call

No more juggling multiple queryExecute() calls. Execute complex database operations atomically:

// Execute multiple statements together
result = queryExecute( "
    UPDATE users SET last_login = NOW() WHERE id = :userID;
    INSERT INTO login_log (user_id, login_time) VALUES (:userID, NOW());
    SELECT * FROM users WHERE id = :userID;
", {
    "userID" : { value: 123, cfsqltype: "numeric" }
} );

Enhanced Metadata Capture

Track generated keys and update counts automatically:

// Know exactly what happened in your database
result = queryExecute( "
    INSERT INTO orders (customer_id, total) 
    VALUES (:customerID, :total)
", params, { result: "insertResult" } );

// Access rich metadata
newOrderID = insertResult.generatedKey;
affectedRows = insertResult.recordCount;

---

🔗 Java Interop Just Got Smarter

Working with Java libraries is now more intuitive than ever. BoxLang 1.5.0 features improved method resolution for overloaded Java methods and better handling of primitive type expectations.

// Complex Java interop now "just works"
formatter = createObject( "java", "java.text.DecimalFormat" ).init( "#,##0.00" );
boxLangNumber = 1234.56;
formatted = formatter.format( boxLangNumber ); // Correctly resolves overloaded method

---

🛡️ Security & Reliability Improvements

Enhanced File Upload Security

The fileUpload() function now includes a blockedExtensions argument for better security:

// Secure file uploads with extension blocking
result = fileUpload( 
    destination = "/uploads/", 
    fileField = "attachment",
    blockedExtensions = [ "exe", "bat", "com" ],
    allowedExtensions = [ "jpg", "png", "pdf", "docx" ]
);

Memory Leak Prevention

Enhanced thread management prevents memory leaks in long-running applications, making BoxLang even more suitable for enterprise production environments.

---

🏗️ CFML Compatibility Enhancements

Script Custom Tag Support

Adobe ColdFusion developers can now use their favorite script-based custom tags:

// CustomButton.cfc (custom tag)
component {
    function onStart() {
        if ( !structKeyExists( attributes, "text" ) ) {
            attributes.text = "Click Me";
        }
        return true;
    }
    
    function onEnd() {
        writeOutput( '<button class="btn btn-primary">' & attributes.text & '</button>' );
        return true;
    }
}

// Usage in template - familiar CFML syntax
bx:customButton text="Save Changes";

Encrypted Datasource Passwords

Security-conscious teams can now use Lucee-style encrypted datasource passwords in their BoxLang configurations.

---

🚀 Real-World Impact

Serverless Applications

• Simplified multi-function architectures with convention-based routing
• Better resource utilization with configurable connection pooling

Data Processing

• Massive parallelization with virtual threads for I/O-bound operations
• Improved throughput for API integrations and data transformations
• Better memory efficiency for long-running batch processes

Enterprise Applications

• Enhanced reliability with memory leak prevention
• Better error messages for easier debugging
• Improved Java interop for complex integrations

---

🎯 Migration Made Easy

The best part? BoxLang 1.5.0 has no breaking changes. Your existing code will run unchanged while automatically benefiting from performance improvements.

Recommended Actions

1. AWS Users: Set the BOXLANG_LAMBDA_CONNECTION_POOL_SIZE environment variable
2. Performance-Critical Apps: Start using virtual threads in your parallel operations
3. File Upload Apps: Add the blockedExtensions argument for better security

---

📥 Get BoxLang 1.5.0 Today

Ready to experience the next evolution of CFML? Download BoxLang 1.5.0 now:

• Download BoxLang 1.5.0
• View Release Notes
• Join the Community

Download

Please visit our download page or our quick installation guides to upgrade your installation.

Professional Open Source

BoxLang is a professional open-source product, with three different licences:

1. Open-Source Apache2
2. BoxLang +
3. BoxLang ++

BoxLang is free, open-source software under the Apache 2.0 license. We encourage and support community contributions. BoxLang+ and BoxLang ++ are commercial versions offering support and enterprise features. Our licensing model is based on fairness and the golden rule: Do to others as you want them to do to you. No hidden pricing or pricing on cores, RAM, SaaS, multi-domain or ridiculous ways to get your money. Transparent and fair.

BoxLang Subscription Plans

BoxLang is more than just a language; it's a movement.

Join us and redefine development on the JVM Ready to learn more? Explore BoxLang's Features, Documentation, and Community.

Join the BoxLang Community ⚡️

Be part of the movement shaping the future of web development. Stay connected and receive the latest updates on Into the Box 2025, product launches, tool updates, and more.

Subscribe to our newsletter for exclusive content.

Follow Us on Social media and don’t miss any news and updates:

• https://x.com/ortussolutions
• https://www.facebook.com/OrtusSolutions
• https://www.linkedin.com/company/ortus-solutions-corp
• https://www.youtube.com/OrtusSolutions
• https://github.com/Ortus-Solutions

Join the BoxLang and CFML legends at Into the Box 2025. Let’s learn, share, and code together for a modern, cutting-edge web development future.