Open at the Core. Ready for Production: BoxLang+, BoxLang++, and the Freedom to Scale
Open source should give developers freedom not push them into a corner when an application becomes successful.
That principle shaped one of the most important segments of the Into the Box 2026 Day 1 keynote: the continued evolution of BoxLang+, BoxLang++, and the growing ecosystem of professional modules surrounding the language.
BoxLang remains a professional open-source project under the Apache 2.0 license. Developers can use the core language and runtime for free, build commercial applications, contribute to the ecosystem, and decide for themselves how far they want to take it.
But the needs of a production team eventually extend beyond language features.
A business-critical application may require guaranteed support response times, security notifications, priority patches, distributed infrastructure, premium document services, secrets management, or direct access to the engineers behind the language.
That is where the commercial BoxLang plans come in.
They are not intended to place artificial restrictions around the language. They give teams a supported path for operating BoxLang in environments where reliability, accountability, and specialized capabilities matter.
Watch the status and future updates during the Day 1 Keynote.
Professional Open Source Without Artificial Limits
During the keynote, the team made its position clear: BoxLang’s licensing should not punish an organization for growing.
The commercial plans are not priced around how much memory an application uses, how many CPU cores are available, whether the application serves multiple domains, or whether the business delivers software as a service.
Instead, the current plans distinguish between standard server deployments and orchestrated environments. BoxLang+ and BoxLang++ orchestrator licenses support unlimited containers or Lambda runtimes within the licensed node.
This gives teams room to design their infrastructure around the application instead of designing the application around an arbitrary licensing restriction.
That distinction matters for modern deployments.
Applications scale horizontally. Containers are replaced. Infrastructure changes. Teams move workloads between physical servers, virtual machines, orchestration platforms, and serverless environments.
A modern language platform should support that movement—not make every infrastructure decision a licensing problem.
Explore the current options on the BoxLang Plans Page
Start Open Source. Add Support When It Matters.
Not every BoxLang project needs a commercial subscription.
The open-source edition includes the core language, runtime capabilities, Java interoperability, community support, development tools, and the foundation needed to build real applications.
For individual developers, internal tools, experiments, community projects, and teams comfortable operating through community support, that may be exactly what is needed.
The commercial plans become relevant when the questions change:
- What happens when this application becomes business-critical?
- Who can our team contact when a production issue cannot wait?
- Do we need a guaranteed support response?
- Are we deploying across multiple servers, containers, or Lambda functions?
- Do we need distributed caching or persistent session storage?
- Does the application require advanced PDF, spreadsheet, CSV, SOAP, REST, LDAP, or secrets-management capabilities?
- Would direct access to BoxLang language engineers reduce operational risk?
The decision is not simply free versus paid.
It is about choosing the level of operational support and capability that matches the responsibility carried by the application.
The Current BoxLang Plan Family
The BoxLang ecosystem now provides four paths: Open Source, Starter, BoxLang+, and BoxLang++.
BoxLang Open Source
The Apache 2.0 open-source edition provides the core BoxLang language and runtime with community-based support.
It is the natural place to begin exploring the language, building applications, evaluating compatibility, and contributing to the ecosystem.
BoxLang does not require a commercial subscription before developers can build something meaningful. The open-source foundation is the product not a temporary preview of it.
BoxLang Starter
Introduced after the keynote material shown here, BoxLang Starter provides an entry point for teams beginning a focused production deployment.
It includes premium modules, five support incidents, and licensing for a single server, container, WAR, or Lambda deployment.
Starter is useful when a team needs more than community support but does not yet require the broader runtime freedom, support coverage, or operational benefits included with BoxLang+ and BoxLang++.
BoxLang+
BoxLang+ is designed for organizations running BoxLang as a supported production platform.
It adds premium modules, a business support SLA, a dedicated support tracker, priority and security patches, a dedicated Slack channel, access to language engineers, and a ForgeBox Pro license.
The current support plan includes up to 12 supported incidents per year, weekday support coverage, and a response-time SLA of less than 12 hours.
For orchestrated infrastructure, the BoxLang+ node license supports unlimited containers, pods, or Lambda runtimes within that licensed node.
This makes BoxLang+ a practical fit for teams that need professional accountability without changing the way they architect or scale their applications.
BoxLang++
BoxLang++ builds on everything included with BoxLang+ and adds a closer operational relationship with the team behind the language.
Current benefits include:
- Enhanced enterprise SLAs
- Expanded support hours and seven-day coverage
- Up to 24 supported incidents per year
- Priority video-call support
- A dedicated account manager
- A personalized yearly technical checkup
- A ForgeBox organization account for up to five users
- A discount on consulting services
BoxLang++ is designed for organizations where BoxLang applications support critical operations and direct access to product experts can materially reduce risk and resolution time.
The value is not simply a larger feature bundle. It is a stronger support relationship for teams that need BoxLang expertise to be available as part of their operational strategy.
Review the latest support coverage and plan details on the official BoxLang plans page.
Premium Modules That Solve Production Problems
The Day 1 keynote also highlighted how quickly the BoxLang+ module ecosystem was expanding.
These modules are not random additions. They address the kinds of integration, data, infrastructure, and compatibility requirements teams encounter when moving real applications into production.
The current premium ecosystem includes capabilities across several important areas.
Distributed Caching and Application State
Modern applications often need to share sessions, cached data, locks, and messages across multiple runtime instances.
The BoxLang Redis module supports Redis servers, clusters, and Sentinel configurations for capabilities such as:
- Distributed caching
- Persistent session and application state
- Publish-and-subscribe messaging
- High-availability configurations
- Distributed coordination
- BoxLang AI memory integrations
The Couchbase module extends this approach into distributed NoSQL document storage, session management, caching, vector search, and persistent AI memory.
These capabilities help teams move beyond sticky sessions and single-server assumptions. Application instances can be replaced or scaled while shared state remains available through the distributed infrastructure.
Explore the Redis module and Couchbase module.
Data and Document Workflows
Business applications continue to depend on documents and structured data, even as their surrounding architecture becomes more modern.
BoxLang’s premium modules provide dedicated capabilities for:
- High-performance CSV parsing and generation
- Spreadsheet creation and manipulation
- PDF generation and modification
- PDF form extraction and population
- Data conversion and export workflows
The CSV module provides both familiar function-based operations and a fluent API. It supports custom delimiters and formatting while converting between CSV data, JSON, queries, and arrays of structures.
These tools allow document-heavy applications to modernize without abandoning workflows the business still needs.
Communication and Legacy Integration
Modernization rarely happens in isolation.
Existing applications may still communicate with SOAP services, expose REST endpoints, work with LDAP directories, exchange email, or connect to systems that cannot be replaced immediately.
The current BoxLang plans include premium communication capabilities for REST, SOAP, LDAP, email, FTP, SFTP, and related services.
This reflects an important part of the BoxLang philosophy: moving forward should not require pretending that existing enterprise integrations no longer exist.
Compatibility gives teams the space to modernize incrementally preserving the systems that still provide value while introducing better architecture around them.
Secrets and Cloud Configuration
Credentials should not be embedded in source code or managed differently throughout every environment.
BoxLang provides secrets-management integrations for AWS Secrets Manager, Azure Key Vault, and Google Secret Manager. These providers work with BoxLang’s configuration system so an application can request a setting through a consistent interface while the underlying value comes from external infrastructure.
That separation makes it easier to use local configuration during development and protected secrets services in production without rewriting application logic for each environment.
Search, AI Memory, and More Specialized Workloads
The keynote also previewed a broader search strategy designed to avoid locking developers into one backend.
The current ecosystem already includes Meilisearch capabilities, Couchbase vector search, and AI memory integrations, while Elasticsearch support remains listed as upcoming on the plans page.
This approach matters because search is not one universal workload. An application may need document indexing, semantic retrieval, session distribution, full-text search, vector memory, or several of those capabilities together.
A modular strategy allows teams to choose infrastructure based on the problem rather than having one search engine permanently embedded into the language.
Modules Without a Monolithic Runtime
A growing module catalog could easily result in a runtime that becomes larger and more difficult to manage.
BoxLang takes a different approach.
Premium modules are independently versioned and installed only when an application needs them. Teams can begin with the core runtime, add one integration, and expand the application’s capabilities over time.
That provides two important advantages:
- Applications do not need to carry every enterprise capability by default.
- New integrations can evolve without requiring each one to become part of the core language.
The bx-plus module acts as the subscription and entitlement foundation for premium capabilities, while specialized modules remain focused on their own responsibilities.
This keeps the platform extensible without turning the runtime into a collection of permanently bundled services.
Commercial Support Is Also a Technical Feature
Support is sometimes treated as something separate from the technology itself.
For a production team, it is part of the architecture.
When a runtime supports customer transactions, internal operations, financial workflows, or public services, the team needs more than access to documentation. It needs a clear escalation path, predictable response times, security communication, and people who understand the internals of the platform.
BoxLang+ and BoxLang++ provide that connection.
A dedicated support tracker creates accountability. Priority patches reduce the time between discovering and resolving a critical problem. A dedicated Slack channel improves communication. Access to language engineers helps teams move beyond surface-level troubleshooting.
BoxLang++ extends that relationship through broader support coverage, video calls, yearly technical reviews, and a dedicated account manager.
Those benefits do not replace good engineering inside an organization. They strengthen it by giving the team a direct path to the people building the runtime.
Which Plan Fits Your Application?
The right plan depends on the application not only its size.
Start with Open Source when:
- You are evaluating BoxLang or learning the language.
- You are building a community or personal project.
- Community-based support is appropriate.
- The core runtime and open-source modules cover your requirements.
Consider Starter when:
- You have one focused production web, container, or Lambda deployment.
- You need premium modules.
- A limited number of professional support incidents is sufficient.
- You want an accessible first step into commercial support.
Choose BoxLang+ when:
- The application is running in production.
- Your team needs a documented business SLA.
- You need premium integrations or distributed infrastructure modules.
- Priority and security patches matter.
- You want direct access to BoxLang language engineers.
- Your deployment needs the flexibility of the full BoxLang runtime ecosystem.
Choose BoxLang++ when:
- BoxLang supports business-critical operations.
- Your organization needs extended or weekend support coverage.
- Faster enterprise response times are required.
- Live video troubleshooting would accelerate incident resolution.
- You want a dedicated account manager and yearly technical review.
- Your team expects an ongoing strategic relationship with the BoxLang engineers.
The question is not, “Which plan has the most features?”
It is, “What level of support, operational confidence, and specialized capability does this application require?”
Build Freely. Scale Deliberately.
The BoxLang+/++ keynote segment reinforced a central idea behind the entire platform.
Developers should be able to begin with a genuinely open language. Teams should be able to build commercial applications without artificial restrictions. And when those applications grow, organizations should have a clear path to professional support and enterprise capabilities without rebuilding on another platform.
That is the role of the BoxLang plan family.
Open Source provides the foundation. Starter supports the first focused production deployment. BoxLang+ adds professional operations and premium capabilities. BoxLang++ creates a deeper support relationship for business-critical systems.
You choose how far the application needs to go.
- Compare BoxLang plans
- Explore BoxLang+ modules
- Download and try BoxLang
- Read the BoxLang documentation
- Join the BoxLang community
Start with the application you have. Add the capabilities you need. Scale without artificial limits.
Explore BoxLang and choose the path that fits what you are building.
Join the BoxLang Community
Be part of the growing BoxLang community. Connect with other developers, ask questions, contribute to the ecosystem, and receive the latest BoxLang news, releases, events, and technical resources.
Stay connected:
- Newsletter: https://newsletter.boxlang.io
- Community: https://community.ortussolutions.com/c/boxlang/42
- Slack: https://www.ortussolutions.com/community/slack
- X: https://x.com/TryBoxLang
- Facebook: https://www.facebook.com/tryboxlang
- LinkedIn: https://www.linkedin.com/company/tryboxlang
- YouTube: https://www.youtube.com/OrtusSolutions
- GitHub: https://github.com/ortus-boxlang
Add Your Comment