We're absolutely thrilled to announce BoxLang v1.4.0 🚀 – without a doubt, our most significant release to date! This isn't just another incremental update; it's a game-changing release that introduces revolutionary features, massive performance improvements, and hundreds of bug fixes that make BoxLang more powerful and developer-friendly than ever before. This is a culmination of over a month of feedback from clients and teams migrating their applications to BoxLang.

If you've been waiting for the perfect time to dive into BoxLang, that time is now. Let's explore what makes this release so special. For the full release notes visit our docs: https://boxlang.ortusbooks.com/readme/release-history/1.4.0

Pluggable Compilers

We have also added a major rework of our compilers to allow you to generate Java code, ByteCode and even a no-op for sourceless deployments coming soon. This means that BoxLang is going to get even SMALLER by our next release by quite a few orders of magnitude. Right now we are clocking at around 7.xMB for the entire language, and we expect this to go down to 5.xMB by 1.5.0 and including more features than before! We’re agile, fast, lean—and we pack a serious punch!

The Async Revolution: Programming Reimagined

The crown jewel of v1.4.0 is our completely revolutionary asynchronous programming framework. This isn't just another async implementation – we've created something that sets a new standard for JVM languages and makes parallel programming accessible in ways that other frameworks simply don't offer.

Why This Changes Everything

While other languages force you to wrestle with complex promises, callback hell, or verbose async/await patterns, BoxLang gives you declarative parallel programming that just works. We've eliminated the boilerplate, the complexity, and the mental overhead that usually comes with async programming.

What makes our async framework revolutionary:

• Zero boilerplate - Write async code as naturally as synchronous code
• Built-in parallel primitives - No need for complex thread management or executor services
• Functional composition - Chain, compose, and transform async operations with ease
• Exception safety - Automatic error propagation and handling across async boundaries
• Performance optimized - Leverages modern JVM concurrency patterns under the hood
• Dedicated logging - Separate async.log and scheduler.log files for complete observability

The New Async Primitives

We've introduced four core async functions that change how you think about parallel programming:

• asyncRun() - Transform any operation into a non-blocking future
• asyncAll() - Execute multiple operations in parallel and aggregate results—no more callback hell
• asyncAllApply() - Map-reduce operations across collections with automatic work distribution
• asyncAny() - Race multiple operations and get the fastest result—perfect for timeout patterns

We have also updated all the list, array, struct and query BIFS to accept a parallel boolean argument and a maxThreads argument to allow you to easily apply parallel constructs to those functions:

• xEach()
• xEvery()
• xFilter()
• xMap()
• xNone()
• xSome()

That's 24 native BIFs with parallel constructs and more coming soon.

See It In Action

// Run multiple operations in parallel
results = asyncAll( [
    () => fetchUserData( userId ),
    () => fetchOrderHistory( userId ),
    () => fetchPreferences( userId )
] );

// Apply function to multiple inputs in parallel
processedData = asyncAllApply( 
    [ "file1.txt", "file2.txt", "file3.txt" ],
    ( file ) => processFile( file )
);

// Get the first completed result
fastestResult = asyncAny( [
    () => callService1(),
    () => callService2(),
    () => callService3()
] );

// Powerful async pipelines - chain operations naturally
userPipeline = asyncRun( () => fetchUser( userId ) )
    .then( user => validateUser( user ) )
    .then( user => enrichUserData( user ) )
    .then( user => cacheUser( user ) )
    .onSuccess( user => auditLog( "User processed: #user.id#" ) )
    .onError( error => logError( "Pipeline failed: #error.message#" ) );

// Advanced scheduling with natural syntax
schedule.task( "data-cleanup" )
    .call( () => cleanupExpiredData() )
    .everyDayAt( "02:00" )  // Every day at 2 AM
    .timezone( "America/New_York" )
    .onSuccess( result => writeLog( "Cleanup completed: #result.recordsDeleted# records" ) )
    .onError( error => sendAlert( "Cleanup failed: #error.message#" ) );

// Weekly reports on business days
schedule.task( "weekly-report" )
    .call( () => generateWeeklyReport() )
    .onFridays( "17:00" )
    .withNoOverlaps()
    .onSuccess( report => emailReport( report ) );

// One-time delayed execution
schedule.task( "send-reminder" )
    .call( () => sendReminderEmail( userEmail ) )
    .delay( 1, "hours" )  // Execute in 1 hour
    .onSuccess( () => writeLog( "Reminder sent successfully" ) );

// Complex parallel data processing pipeline
reportData = asyncRun( () => fetchRawData() )
    .then( data => asyncAllApply( data, row => processRow( row ) ) )
    .then( processedRows => aggregateResults( processedRows ) )
    .then( summary => generateReport( summary ) )
    .onSuccess( report => emailReport( report ) )
    .get();  // Block and get the final result

This is async programming reimagined. The code reads almost like pseudocode but is fully functional and performant. That's the power of BoxLang's design philosophy.

Learn More: We've created comprehensive documentation covering every aspect of async programming, from basic concepts to advanced patterns. Check out our complete Asynchronous Programming Guide, including detailed sections on Executors, BoxFutures, Async Pipelines, Parallel Computations, and Scheduled Tasks.

MiniServer: From Development Tool to Production Powerhouse

The BoxLang MiniServer has received a complete transformation in v1.4.0. What started as a simple development server is now a production-ready runtime with more capable features. Remember, if you want a proven enterprise servlet web server, then CommandBox is your choice!

Automatic Environment Variable Support

Configuration management just became effortless. The MiniServer now automatically detects and loads .env files from your webroot directory:

# .env file in your webroot
DATABASE_URL=jdbc:mysql: //localhost:3306/mydb
API_KEY=your-secret-api-key
DEBUG_MODE=true
REDIS_URL=redis://localhost:6379

When you start the server, you'll see:

+ Loaded environment variables from: /path/to/webroot/.env

These variables are automatically available throughout your application, following 12-factor app principles and making cloud deployments seamless.

Enterprise-Grade Health Check Endpoints

This might be our favorite new feature. The MiniServer now includes comprehensive health monitoring that integrates perfectly with container orchestration and load balancers:

# Basic health checks
boxlang-miniserver --health-check

# Secure health checks for production
boxlang-miniserver --health-check --health-check-secure

You get three essential endpoints:

• /health - Complete health information with system metrics and JVM details
• /health/ready - Readiness probe for load balancers
• /health/live - Liveness probe for container orchestration

The health response includes everything you need for monitoring:

{
  "status": "UP",
  "timestamp": "2025-08-01T17:05: 47.587438Z",
  "uptime": "1m 47s",
  "uptimeMs": 107245,
  "version": "1.4.0-snapshot+0",
  "buildDate": "2025-08-01 16:03: 36",
  "javaVersion": "17.0.2",
  "memoryUsed": 152093696,
  "memoryMax": 4294967296
}

Advanced Security Protection

Security is now built-in, not bolted-on. The MiniServer automatically protects against common vulnerabilities:

• Hidden File Protection - Automatically blocks access to .env, .git, .htaccess, and any hidden files
• Secure Health Checks - Full metrics for localhost, basic status for remote requests
• Production-Ready Defaults - Secure by default, no additional configuration required

When you start the server, you'll see:

+ Security protection enabled - blocking access to hidden files (starting with .)

These MiniServer enhancements make BoxLang perfect for:

• Container deployments with Kubernetes and Docker Swarm
• Load balancer integration with HAProxy, nginx, and cloud load balancers
• Cloud-native applications following modern deployment patterns
• Enterprise monitoring with APM tools and health monitoring systems

More Powerful Features

Enhanced ZIP Functionality

New zipparam support provides fine-grained control over ZIP operations:

zip( action="zip", file="myarchive.zip" ) {
    zipparam( source="folder1/", prefix="backup/" );
    zipparam( source="file.txt", entrypath="documents/readme.txt" );
}

Nested Grouped Output/Looping

Enhanced support for complex nested grouping in queries and loops:

bx:loop( query="salesData", group="region,quarter" ) {
    writeOutput( "<h2>#region# - #quarter#</h2>" );
    
    bx:loop() {
        writeOutput( "<p>Sale: #amount# on #date#</p>" );
    }
}

Enhanced BoxLang Mappings

Mappings now support an external flag (defaults to false) for better module organization and security.

Performance That Matters

We didn't just add features – we made everything faster:

String Performance Revolution

• Significant performance improvements for toScript() BIF
• Optimized string operations throughout the runtime
• Better memory management for large string operations

Custom Component Lookup Optimization

• Refactored custom component and class lookup for improved performance
• Better caching mechanisms for frequently accessed components
• Reduced overhead in component resolution

JSON Processing Improvements

• Removed JSON serialization limits
• Enhanced JSON serialization of throwable objects
• Better handling of complex object graphs

Language & Runtime Excellence

Enhanced Date/Time Handling

• Support for more natural date parsing masks (case-insensitive)
• Better timezone handling in DateTimeCaster
• Improved CFML compatibility for partial years

Improved Type Coercion

• Skip type coercion for === operator (strict equality)
• Better handling of Java arrays in modifiable contexts
• Enhanced casting between BoxLang DateTime and Java Date types

Better Error Handling

• Improved error messages in expression interpreter
• Enhanced attempt.orThrow() handling
• Better parsing errors for unclosed brackets

Hundreds of Bug Fixes

We've addressed hundreds of issues across the platform:

JDBC & Database

• Fixed race conditions in threaded query execution
• Resolved nested transaction issues
• Improved query caching with Redis integration

File Operations

• Fixed cfcontent file corruption issues
• Better handling of relative file paths
• Enhanced multipart form handling

Session Management

• Fixed session rotation and invalidation issues
• Better SameSite cookie attribute handling
• Improved session lifecycle management

Comprehensive New Documentation

We've significantly expanded our documentation with brand-new comprehensive guides:

• MiniServer Guide - Complete setup and configuration
• Components Guide - In-depth component development
• Transactions Guide - Database transaction management
• XML Processing Guide - Working with XML in BoxLang
• Property Files Guide - Configuration management
• Testing Guide - Testing best practices and frameworks

Plus our comprehensive asynchronous programming documentation that covers everything from basic concepts to advanced enterprise patterns.

CFML Compatibility Enhanced

This release includes numerous CFML compatibility enhancements:

• Better parseDateTime compatibility with ACF
• Improved handling of date masks and formatting
• Enhanced numeric operations and casting
• Better list BIF consistency across multi-character delimiters

The Architecture Updates

We've modernized the entire platform:

Dependency Updates

• Updated Jackson-jr to latest patch version
• Bumped semver4j from 5.8.0 to 6.0.0
• Updated Apache Commons components
• Enhanced base64 and encoding support

Code Organization

• Refactored component directory structure for better organization
• Improved scope naming for consistency
• Removed unnecessary external dependencies

What This Means for You

BoxLang v1.4.0 isn't just an update – it's a statement. We're showing the world that JVM languages can be modern, powerful, and delightfully simple to use. Whether you're building:

• Modern web applications with our revolutionary async framework
• Microservices with the production-ready MiniServer
• Enterprise applications with enhanced CFML compatibility
• Cloud-native solutions with built-in health checks and environment support

BoxLang v1.4.0 has you covered.

Join the Revolution

The future of JVM development is here, and it's more exciting than ever. With revolutionary async programming, production-ready deployment options, and a commitment to developer experience that's second to none, BoxLang is ready to power your next generation of applications.

Download BoxLang v1.4.0: GitHub Releases

Get Started: BoxLang Documentation

Join Our Community: Connect with us on Discord or visit our community forums

Thank You to Our Community

This release represents months of hard work from our development team and invaluable feedback from the BoxLang community. Thank you to everyone who reported issues, suggested improvements, and contributed to making BoxLang better!

The future is bright, and it's written in BoxLang. Welcome to v1.4.0 – let's build something amazing together! 🚀

---

Ready to experience the revolution? Download BoxLang v1.4.0 today and see why developers are calling it the future of JVM development.

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://twitter.com/ortussolutions
• https://www.facebook.com/OrtusSolutions
• https://www.linkedin.com/company/ortus-solutions/
• 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.