As we approach a stable release of BoxLang and our continued marketing reaches more folks, many have asked about its purpose. Why create a new language when the JVM ecosystem already includes established languages like Kotlin, Groovy, and Scala, to name a few.

I believe these are great and relevant questions. We had several motivations that ultimately made us create BoxLang. The decision to do this has spanned over six years of research, contemplation, and prayer; so it has not been rash or spur-of-the-moment. It has been a calculated decision, culminating in over 18 years of creating frameworks and libraries for the ColdFusion/CFML and Java communities. It has definitely not been an easy decision to embark on this journey at all. We knew from the start that this would be a gargantuan task and that we could fail at any time. However, we knew that if we did it, that we would go all in, no reservations, no retreats and no regrets. The rewards would come.

With that said, let's examine these questions by looking at the three languages mentioned above. I'll focus on those for now, rather than discussing ColdFusion/CFML, since we've already covered our reasons for not pursuing either commercial or open-source vendors elsewhere.

Facts

• Kotlin is a statically typed language, a different paradigm than the dynamic world we wanted to inhabit. It was released more than 8 years ago, and it has great features surrounding lower verbosity and ceremony than core Java. Due to JetBrains pushing it, it has great multi-platform design and tooling. It does not have framework-like features, no templating language, just a leaner, simpler, and more functional counterpart to native Java.
• Groovy has been one of my favorite languages for many years, and they did many things right. It is a dynamic language with great meta-programming, like CFML, scripting, Java interop, and DSLs. However, development has stagnated recently, and it was designed and released over 20 years ago. There is no multi-platform design, a basic templating language, few extension points, and a monolithic core.
• Scala was also designed and released over 20 years ago. It is statically typed with type inference, so it is not a pure dynamic language. There is a great focus on functional programming, lower verbosity, immutable constructs, monads, and more. There is no multi-platform design, no native templating language, modular extensions, or event-driven extensions.

This is a short synopsis of the three aforementioned languages from our internal conversations and analysis. However, the point is not their overarching capabilities, but what exactly we needed as developers and as a company to continue to develop the solutions that we wanted. We really wanted and needed many facets of all these languages in one.

All languages currently are similar in semantics and constructs, from loops, to variable declarations, classes, types, no types, etc. What sets them apart in the world we live in today, is entirely different from the world in which most of these languages were designed 30, 20, or 10 years ago. We have many platforms, many languages, many variations, many deployments, etc. For what we wanted to do, our choice was ever clearer, we needed a path forward dictated by our needs.

Vision

At Ortus, we have worked with these languages and many others for more than 20 years. In reality, we wanted to be able to not only carry the mantle of a new CFML productivity language but also embrace and adopt the times that we live in: multi-runtimes, dynamic modifications, agility, modularity, Artificial Intelligence (AI), cross-language dependencies, embedded runtimes, and so much more. We had customer demands and framework demands we wanted to address.

Our only path forward was to design a new language with framework capabilities that could embrace all the great things we love about Java, Kotlin, CFML, Groovy, Scala, Clojure, Rust, and more. This led us to BoxLang and its fundamental vision of architecture in the following 10 pillars of concern:

1. Bytecode & Multi-Runtime
   • Compile to Java byte code and exist and run anywhere like our predecessors.
   • Embed BoxLang into any JVM application if needed to leverage its framework components
   • The ability to run and script at the core level of an operating system and expand in layers to other runtimes like embedded processors, watches, phones, tablets, servers, docker, cloud engines, serverless, and whatever comes in the next 25-50 years.
2. Multi-Parser & Java Interop
   • We wanted to design a new language and syntax and be able to transpile other languages into the BoxLang AST (Abstract Syntax Tree) so they could run natively in our runtime. We started with CFML and then we will move into other languages like Groovy and even PHP. This means that your existing CFML code runs natively in BoxLang. This means, that in the future, your native Groovy code will run natively in BoxLang.
   • This not only allows us to have a consistent starting point for transpilations but also enables us to build static code analysis tools and IDE tools.
   • Access any Java library with complete interoperability in BoxLang. You can extend, implement, create, and generate code seamlessly.
3. Dynamic Programming with InvokeDynamic
   • We've witnessed the incredible power and productivity that dynamically typed languages offer. We wanted to deepen this advantage by providing enhanced type inference, promotions, auto-boxing, down-boxing, and type coercions. Recognizing the strengths of statically typed languages, we also aimed to deliver top-class tooling and optional typing in some areas—bringing you the best of both worlds.
   • As a dynamic and modern language, BoxLang leverages cutting-edge JDK features from version 21 onward, particularly InvokeDynamic constructs. We have created an entire framework we call DynamicObject that provides the capability for any runnable class to become dynamic even if it’s not built dynamically.
4. Cross-Language
   • Thanks to JSR-223, dynamic programming, and modularity pillars, we wanted to envision a world where we could load different language runtimes into BoxLang and execute and interact with Python, JavaScript, PHP, Groovy, etc. In BoxLang you can now load and interact with Python libraries (bx-jython), with many more language runtimes coming soon.
5. Functional & Metadata Programming
   • This is another great legacy of the CFML/Groovy world, and we wanted to continue it but delve deeper and integrate pure functions, unmodifiable constructs, streams, completable futures, scheduling and more.
   • Almost all of our current frameworks (MVC,DI,BDD,TDD,AOP) leverage metadata. We meticulously wanted to introduce not only dynamic annotations, but also meta programming to extend any class, not only BoxLang classes, but ANY class.
6. Event-Driven Programming & Modularity the Right Way
   • This is what sets many of our frameworks apart from others. BoxLang should be an event-driven language at its core. It extends via events, whether synchronous or asynchronous.
   • ColdBox was one of the world's first Hierarchical Model View Controller frameworks, even before OSGI. This would allow us to bring those aspects and features to help us extend our core into ANY runtime or ANY feature via the creation and isolation of modular portions of the language.
7. Framework Capabilities & Templating Language
   • Since 2006, we have written more than 350 open-source libraries to assist our developer communities. We wanted to grasp our modular approaches and event-driven constructs to bring productivity layers to the language so as not to reinvent the wheel. From scheduling, tasks, WebSockets, PDF and document services, file management, web API connectivity, security, and more, BoxLang gives you the power to build any application quickly, securely, and automatically.
   • Another great legacy from the CFML world, but taken to yet another level: providing modular extensibility and event-driven extensions. We learned from other UI templating languages to provide ease of use, speed, and reactivity.
8. Professional Open-Source
   • Believe it or not, this was a huge item on our list. Developers and Companies need to be able to get support and help when they need it the most. It’s great that some of these languages are open-source, but they are not professionally supported directly.
9. Documentation
   • This is an area that we love, and it is non-negotiable for anything we do at Ortus. Finding the right documentation for some of these languages can sometimes be painful, so we wanted to make sure we could take documentation to the next level.
10. Tooling, Testing & Automation
    • We need top-class tooling for BoxLang to be relevant and productive. It had to work with generative AI IDEs, Language Server Protocols, Direct Compilation, Direct Transpilation, and, more importantly, a line debugger that could be attached to ANY running BoxLang process from day 0.
    • For over 15 years, we created and maintained the foremost Test and Behavior-Driven Development frameworks for CFML. Testing had to be a core part of these initiatives. To this day, we have over 40 BoxLang repositories with over 8,000 tests.

Our Reality

I could go on, but these are the top, fundamental, and non-negotiable pillars we wanted BoxLang to be designed upon. These are some of the significant reasons BoxLang exists, as we could not grasp or capture the vision of what we wanted to do in the current state of the JVM. We had to create it. AI via OpenAI and GitHub Co-Pilot has been an integral part of our journey, catapulting us to build the language, tests, and, yes, thousands of pages of documentation.

We are now on Beta 25, and we have achieved most of these pillars and gone above and beyond in some areas we never knew we could accomplish. This has been achieved with the amazing Ortus team in about 15 months' worth of part-time development due to our client commitments. We have just scratched the surface on many points, and the possibilities of extending even further to further areas keep arriving, motivating us that we are on the right track.

We are not yet where we want to be, but we are making lightning-fast progress to our very first stable release, which will not only launch these pillars into reality but also run ALL of our historical 350 libraries, websites, SaaS applications, and over 18 years of development with BoxLang. So, we can launch with three ecosystems from day 0: Java, CFML, and BoxLang.

We are not satisfied with the status quo, are not big tech, and don’t have droves of VC capital to burn. We have a motivated team that wants to revolutionize the way we develop our applications and treat our customers, and we can code and run it ANYWHERE. Our ultimate goal is to make you productive; that’s what BoxLang is all about.

Join Our Revolution

As we continue our journey to stable release and beyond, we would love your help in any capacity, from code testing to helping folks get started, reviewing applications, making videos, or just helping us spread the word.

Website: https://boxlang.io

Try it Now: https://try.boxlang.io

Docs: https://boxlang.ortusbooks.com

GitHub: https://github.com/ortus-boxlang/boxlang

VSCode IDE: https://marketplace.visualstudio.com/items?itemName=ortus-solutions.vscode-boxlang