11 months. 13 releases. Production workloads already running. If you haven’t evaluated BoxLang yet, now is the time.
https://www.ortussolutions.com/blog/boxlangs-first-11-months-explosive-growth-developer-empowerment-and-the-return-of-dynamic-languages
At Into the Box 2026, Ortus Solutions pulled back the curtain on something that deserves serious attention from every technical leader building on the JVM: BoxLang is not a hobbyist language experiment. It is a production-grade, actively evolving development platform with enterprise adoption already underway and a runtime footprint that now reaches places Java simply cannot go.
Watch the keynote: https://www.youtube.com/embed/8i6mQt-C-Vo
What BoxLang Actually Is
BoxLang is a modern, dynamic language built natively on the JVM. It offers 100% Java interoperability, modern constructs, a full framework approach to development, and a syntax designed for developer productivity without sacrificing the performance and ecosystem depth that Java engineers expect.
It carries a lineage rooted in CFML, Groovy, Rust, and Core Java, bringing decades of battle-tested web development patterns to a modern runtime architecture. But BoxLang is not a port or a compatibility layer. It is a full reimagining of what a dynamic JVM language should look like in 2025 and beyond.
For Java teams, that means you get dynamic productivity — fast iteration, concise syntax, powerful built-in functions — while keeping full access to the Java ecosystem, your existing libraries, and your existing infrastructure. You can either build new apps in pure BoxLang, or add BoxLang as just another library to your existing Java apps via Maven or Gradle. There is even a dedicated runtime for Spring Boot so you can take advantage of BoxLang’s modern templating language.
It’s also more than just a language. BoxLang was designed by framework authors, so BoxLang is a development framework as well, with a rich modular architecture and over 50+ curated modules by the BoxLang team. From AI capabilities to PDF manipulation, image manipulation, OSHI, IoT, MCP, JWT, and so many other extensible features.
Full documentation: https://boxlang.ortusbooks.com/
The Runtime Story: Deploy Everywhere
This is where the CTO conversation starts.
Most languages give you one or two deployment targets. BoxLang gives you 30+, and that number is growing. The platform has been explicitly engineered for deployment flexibility, meaning your team writes code once and chooses the runtime that fits the workload.
JVM-based runtimes today:
- Operating System CLI — scripting, automation, batch processing, cron replacement
- CommandBox — the primary developer CLI, package manager and Servlet Container (commandbox.ortusbooks.com)
- MiniServer — lightweight embedded web server for development and lightweight deployments
- Lambda — AWS serverless with cold-start optimizations
- Jakarta EE — full enterprise Java container support
- Docker Native — containerized deployments with official images
- Spring Boot — embed BoxLang directly inside your Spring application
- Google Cloud Functions (GCF) — serverless on GCP
- DigitalOcean App Platform — managed cloud deployment
- Desktop — Electron-based and JavaFX desktop runtime
- GitHub Actions — CI/CD automation and scripting
- LSP — Language Server Protocol for IDE integration across 7+ editors
18+ cloud server offerings are already available across major providers.
The MatchBox Rust Runtime: Where Java Cannot Go
The most significant architectural announcement is MatchBox — BoxLang’s Rust-based runtime engine.
Java has an inescapable constraint: the JVM. It is an extraordinary piece of engineering, but there are deployment targets it simply cannot reach. MatchBox was built precisely to eliminate that constraint. It is a native BoxLang runtime written in Rust, and it unlocks the following targets:
- WebAssembly (WASM) — run BoxLang in the browser or in WASM sandboxes
- WASM + Docker — containerized WASM deployments
- ESP32 — microcontroller and embedded hardware deployments
- Native Image — compiled native binaries with near-zero startup time and minimal memory footprint
- Native Web Server — a pure native HTTP server with no JVM dependency
This is a fundamental expansion of the targets that BoxLang-based applications can target. Teams that want to write business logic once and deploy it across cloud, edge, embedded hardware, and browser environments now have a credible path to do that from a single language and ecosystem.
It’s also a great architectural decision of abstraction, where developers can focus on BoxLang source and not on where it will run. The runtime will take care of that for you!
AI-Native From Day One
The bx-ai module is BoxLang’s first-class AI integration layer. This is not a thin wrapper around an API. It is a full agent framework built into the language runtime.
Key capabilities:
- LLM Agents with tool use — build autonomous agents that reason, plan, and call tools
- Agent Registry — manage and compose multiple agents across your application
- MCP client and invoker support — connect your BoxLang applications to any Model Context Protocol server or become an MCP server seamlessly
- Image generation — native support for AI image pipelines
- Web search integration — agents with live internet access
- Fluent Audio API — text-to-speech and audio generation workflows
- Streaming (SSE) — real-time AI response streaming built into the runtime
For teams building AI-augmented applications, BoxLang lets you move from prototype to production without switching languages or frameworks.
bx-mcp: Your AI Assistant Can Now Interrogate Your Live Runtime
This is the feature that changes the operational story for enterprise BoxLang deployments.
bx-mcp is a production-ready Model Context Protocol server embedded directly in the BoxLang runtime. It is available to BoxLang+ and BoxLang++ subscribers and exposes 154 MCP tools and 32 pre-built diagnostic prompts over HTTP via JSON-RPC 2.0.
What that means in practice: you point any MCP-capable client — Claude Desktop, VS Code Copilot, Cursor, or your own tooling — at your live production runtime, and your AI assistant gains direct, structured access to everything happening inside it.
What bx-mcp exposes:
- Runtime introspection — BoxLang version, configuration, BIFs, components, global services
- JVM diagnostics — memory, threads, CPU, GC activity, hot thread analysis, deadlock detection, heap dumps, disk and file descriptor usage
- Data layer analytics — cache hit rates, datasource pool metrics, slow SQL capture, connection pool latency histograms
- HTTP and web observability — outbound HTTP/SOAP client stats, slow request analysis, per-route metrics, Undertow server diagnostics
- Operations monitoring — async executor health, scheduler management, module lifecycle, interceptor registry, application lifecycle, log analysis
- Structured health reports — unified health snapshots across all subsystems with scoring, issue codes, and actionable recommendations
- Incident response workflows — pre-built triage, error spike analysis, cascade failure diagnosis, rollback decision support, and post-incident review
For a CTO evaluating operational maturity, this is significant. The question is no longer “can we get visibility into what the runtime is doing?” The answer is yes, and that visibility is queryable by AI tools your team is already using.
Full documentation: https://boxlang.ortusbooks.com/boxlang-+-++/modules/bx-mcp
Ecosystem Velocity: The Numbers That Matter
Technology bets require confidence in platform longevity. Here is what 11 months of BoxLang development looks like:
| Metric | Result |
|---|---|
| Minor releases | 13 |
| New features delivered | 82+ |
| Runtime improvements | 258+ |
| Bugs resolved | 500+ |
| Automated tests | 16,000+ (up from 12,000) |
| Repositories | 86 (up from 30) |
| Official modules | 55+ (up from 30) |
| Contributors | 30+ (up from 10) |
| Supported runtimes | 30+ |
| Cloud server offerings | 18+ |
| IDE integrations | 7+ |
This is not a language that ships a major release once a year and calls it done. The Ortus team ships continuously, and the scope of what is landing — new language features, new runtimes, new AI capabilities, new operational tooling — signals a team that is building with a long-term architectural vision, not just maintaining a codebase.
GitHub activity: https://github.com/ortus-boxlang/BoxLang
Three Ecosystems, One Platform
BoxLang occupies a rare position in the JVM landscape: it is simultaneously relevant to three distinct developer communities.
For Java and JVM teams, BoxLang offers dynamic language productivity without abandoning the JVM. You can embed BoxLang via JSR-223 in an existing Java application, use it to script and automate alongside your Java services, or build new services in BoxLang that interoperate directly with your Java code and libraries via Maven or Gradle.
For ColdFusion and CFML teams, BoxLang is the modern path forward. Applications can migrate incrementally, the language retains familiar patterns, and teams gain access to the full BoxLang runtime ecosystem — including all the deployment targets, AI capabilities, and operational tooling that ColdFusion never offered.
For teams building net-new applications, BoxLang removes a fundamental tradeoff. You no longer have to choose between JVM reliability and dynamic language speed-of-development. You get both, with a module ecosystem (forgebox.io) that covers database connectivity, caching, messaging, AI, PDF generation, image processing, JWT, search, and much more out of the box.
BoxLings: Getting started
BoxLings is an interactive CLI tool that guides you through learning BoxLang fundamentals through hands-on exercises with intentional errors. You fix the code, run tests, and progress through topics at your own pace.
https://github.com/ortus-boxlang/boxlings
What makes BoxLings special? It teaches you TDD/BDD alongside BoxLang! Tests are visible and part of the learning experience. Read the tests first to understand the requirements, then fix the code to make them pass.
The Strategic Case
The JVM is not going anywhere. Java remains one of the most deployed platforms on the planet, and the enterprises running on it are not rewriting everything in a different runtime stack.
What they are doing is looking for ways to move faster, integrate AI more deeply, reduce operational friction, and deploy workloads to more targets without multiplying their language surface area.
BoxLang addresses all of that from a single platform. It runs on the JVM where the JVM is the right choice. It runs natively via MatchBox where the JVM is not. It integrates AI at the language level, not the library level. And it gives operations teams structured, AI-queryable visibility into what is happening in production.
Eleven months in, with production workloads already running and a pace of development that most language teams would envy, BoxLang has earned a serious evaluation from any technical leader building on the JVM.
The dynamic language is back. And this time, it runs everywhere.
For more information, visit https://boxlang.io/ or explore the full documentation at https://boxlang.ortusbooks.com/.
