JVM Languages on JAVAPRO International

BoxLang’s First 11 Months: Explosive Growth, Developer Empowerment, and the Return of Dynamic Language!

Fri, 03 Jul 2026 12:00:01 +0000

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.

BoxLang 1.14.0 : Query Transformers: Take Full Control of Your Query Results

Wed, 01 Jul 2026 12:00:01 +0000

BoxLang 1.14.0 ships a lot of exciting features – Dynamic Sets, Ranges, Inner Classes, JSONPath navigation – but one quietly powerful addition will change the way you think about every database call in your application: Query Transformers, and this is just the start, we have plans for a whole lot more cool query features.

If you have ever executed a query and then immediately written a loop to reshape the result into what you actually needed, this feature is for you.

BoxLang 1.14.0 : Introducing Inner Classes

Mon, 29 Jun 2026 12:00:02 +0000

BoxLang has always embraced a simple truth: the way you organize code shapes the way you think about problems. For a long time, if you needed a helper class, you needed a file. One class, one .bx file, no exceptions. This also stemmed from the CFML days. That’s clean and predictable, but it creates real friction when a class is tightly coupled to exactly one caller and has no business existing anywhere else.

BoxLang 1.14.0 : BoxSet is Here: BoxLang's New First-Class Set Type

Fri, 26 Jun 2026 12:00:01 +0000

BoxLang 1.14.0 ships with a new dynamic first-class Set type baked directly into the language. Not a wrapper you reach for manually, not a createObject( "java", "java.util.HashSet" ) incantation you paste from a Stack Overflow answer years ago. A real BoxSet with literal syntax, operator overloads, a full functional pipeline, change listeners, JSON serialization, and deep Java interop.

If you have ever deduplicated an array with a loop, compared two collections element by element, or modeled a permission system on top of a struct – Sets are the tool you were missing. Let’s dig in.

BoxLang 1.14.0 : Sets, Ranges, Inner Classes, and a Runtime That Talks Back

Wed, 24 Jun 2026 12:00:01 +0000

BoxLang has never stood still, but version 1.14.0 is something different. This is the release where the language stops filling gaps and starts defining what a modern dynamic JVM language looks like on its own terms. Sixty-five issues closed. Four innovative language features. A formatter that has grown up. And a companion module - bx-mcp - that fundamentally changes how you operate a running BoxLang application with AI.

This could have easily been a major release for the team. This has been a really amazing effort by everybody at Ortus, and we’ve received great feedback from our clients migrating to BoxLang and coming up with innovative ideas for this platform. We have only just begun!

Introducing bx-jwt: Enterprise-Grade JSON Web Tokens for BoxLang

Tue, 23 Jun 2026 12:00:02 +0000

JWT authentication is everywhere. But rolling it correctly — with proper algorithm enforcement, key management, clock skew handling, JWE encryption, and zero security footguns — is anything but trivial. Today, we’re shipping bx-jwt, a production-ready JWT/JWE module for BoxLang that handles all of it out of the box, so you can focus on building, not fighting cryptography.

bx-jwt is part of the BoxLang+ and BoxLang++ subscription tiers — our enterprise-grade module collection built for teams that take security seriously.

Introducing BoxLings! An interactive teacher for BoxLang and TDD/BDD

Wed, 17 Jun 2026 12:00:03 +0000

We believe the best way to learn a programming language is by writing code — real code, with real feedback, and real tests. That’s exactly why we built BoxLings.

Inspired by the beloved Rustlings project, BoxLings is an interactive CLI tool that teaches you BoxLang through hands-on exercises. You read failing tests, fix broken code, and level up — one exercise at a time.

Oh, and the whole thing is written in BoxLang itself. 🥊 Dogfooding at its finest.

BoxLang v1.13.0: Compatibility, Concurrency, and Formatter Maturity

Mon, 15 Jun 2026 12:00:02 +0000

BoxLang 1.13.0 is a stability-first release with deep compatibility work and runtime hardening. This build closes 48 issues, with the majority focused on CFML compatibility edge cases, concurrency correctness, formatting parity, and miniserver/runtime reliability under real production loads.

While this release is bug-fix heavy, it still introduces several meaningful features and quality-of-life improvements: character-aware trimming, class metadata lookup by absolute path, process environment control in SystemExecute(), SOAP headers, new query column rename capabilities, and safer miniserver routing/security defaults.

BoxLang Goes Serverless on Google Cloud

Wed, 10 Jun 2026 12:00:01 +0000

We just shipped the BoxLang Google Cloud Functions Runtime — and it brings the same write-once-run-anywhere serverless experience you already know from our AWS Lambda runtime, now running natively on Google Cloud Functions Gen2.

The big idea is simple: the same .bx handler file you deploy to AWS Lambda works on GCF without modification. One codebase. Two clouds. Zero rewrites.

The Architecture

The GCF experience is intentionally split into two projects:

Build Cross-Platform Desktop Apps with BoxLang

Mon, 08 Jun 2026 12:00:00 +0000

Today we’re shipping the initial release of the BoxLang Desktop Runtime — powered by Electron, BoxLang, and Vite. With one starter, one npm run dev, and one packaging command, you can build and distribute professional desktop applications for macOS, Windows, and Linux using the BoxLang you already know. 🎯

This is BoxLang’s newest runtime joining a deliberately growing list — web servers, AWS Lambda, Google Cloud Functions, Android (in development), and now desktop. Same language, same idioms, same modules — different shell. Write once, deploy where your users are. 🚀

BoxLang AI 3.2.0 — Image Generation, Web Search, Fluent Audio, Agent Registry & MCP Observability

Fri, 05 Jun 2026 12:00:01 +0000

BoxLang AI 3.2.0 is here, and it’s a landmark release. We’re shipping five major features: image generation, web search, a fluent audio builder API, a centralized agent registry, and deep MCP observability along with a suite of analytics improvements and a critical bug fix. Let’s dig in. 🎉

🖼️ Image Generation — `aiImage()`

You can now generate images directly from BoxLang using any provider that supports text-to-image generation. The aiImage() BIF follows the same fluent, chainable philosophy as the rest of bx-ai then act on the result with expressive method calls.

Introducing skills.boxlang.io — The Open Agent Skills Ecosystem for BoxLang & the Ortus World

Wed, 03 Jun 2026 12:00:03 +0000

Today we’re launching something we’ve been quietly building for months: skills.boxlang.io — a public, agent-agnostic directory for AI skills covering BoxLang, ColdBox, TestBox, CommandBox, and the entire Ortus ecosystem.

If you’ve ever pasted a 400-line system prompt into yet another AI agent, watched two of your bots drift onto subtly different versions of the same coding standard, or spent half a Friday afternoon trying to convince an LLM that BoxLang is not Java and is not CFML, or how to code for Modern CFML; this launch is for you. 🎯

Announcing MatchBox Open Beta: BoxLang, Now Running in New Places

Mon, 01 Jun 2026 12:00:00 +0000

Ortus Solutions is excited to announce the open beta of MatchBox, a new open source project in the BoxLang ecosystem. MatchBox is a custom BoxLang virtual machine written in Rust. It is built for the places where a full JVM runtime is not the right fit: small native command-line tools, compact web services, browser applications, WebAssembly containers, and even embedded hardware like ESP32 devices.

The project started in early March and has been moving quickly - already at v0.5.0. That speed is part of why we are opening the beta now. MatchBox is already capable enough to build real experiments, prototypes, and early applications, but it is still beta software. APIs will change. Some language features are still being implemented. Some deployment targets are intentionally limited while we harden the runtime. We want developers to try it, break it, ask questions, and help shape where it goes next.

Kotlin kontra Java - Part 3 - Language for Interop

Thu, 07 May 2026 07:00:01 +0000

When you start a new project on the JVM, should you pick Java or Kotlin? Why not both?

You can use any Java library you want in Kotlin, you can even co-write your software in both languages (e.g. one team I work with writes their JUnit tests in Kotlin, their main code in Java) and migrate to Kotlin or back to Java over time. Kotlin is designed with Java interoperability in mind, because JetBrains wanted to migrate their IDEs (IntelliJ IDEA, WebStorm, etc.) incrementally to the language. But how does that work? What does Kotlin do, so that interop to this degree becomes possible?

Kotlin kontra Java - Part 2 - MultiPlatform

Wed, 22 Apr 2026 07:45:01 +0000

When you start a new project on the JVM, should you pick Java or Kotlin?

You might have a preference based on the ecosystem — the tooling around it, who we can ask for help, and the libraries we can use — which we discussed in part 1 of this article series. Or you might have a preference based on the business modeling capabilities of Java or Kotlin, which we will show in part 3.

How to Develop AI Agents Using BoxLang AI: A Practical Guide

Mon, 20 Apr 2026 12:00:01 +0000

AI agents are transforming how we build software. Unlike traditional chatbots that just answer questions, agents can reason about what tools they need, decide when to use them, chain multiple actions together, and remember what happened earlier in a conversation.

In this tutorial, I’ll show you how to build a real-world AI agent using BoxLang AI — the official AI framework for the BoxLang JVM language. We’ll build SupportBot, an e-commerce customer support agent that can look up orders, check inventory, issue refunds, and answer questions grounded in your knowledge base.

BoxLang AI Deep Dive — Part 7 of 7: MCP — The Protocol That Connects Everything 🔌

Fri, 17 Apr 2026 12:00:01 +0000

BoxLang AI 3.0 Series · Part 7 of 7

The AI ecosystem has a tool problem. Every framework has its own way of defining tools, every agent has its own way of calling them, and every integration requires custom code on both sides. An agent built in Python can’t easily use tools built in Java. An MCP server written for Claude Desktop can’t easily be consumed by a BoxLang agent without a custom adapter.

BoxLang AI Deep Dive — Part 6 of 7: Memory Systems & RAG — Building AI That Remembers 🧠

Thu, 16 Apr 2026 12:00:01 +0000

BoxLang AI 3.0 Series · Part 6 of 7

A chatbot with no memory isn’t a conversation — it’s a series of isolated queries. Every message starts from scratch. The user has to re-explain who they are, what they’re working on, and what was just said. It’s exhausting, and it signals that the AI isn’t really listening.

Memory is what separates a useful AI application from a toy. BoxLang AI ships with one of the most comprehensive memory systems in any AI framework — 20+ memory types across two major categories, vector embedding support for semantic retrieval, 30+ document loaders for RAG pipelines, and a per-call identity routing system that makes multi-tenant applications safe by default.

Kotlin kontra Java - Part 1 - Ecosystem

Thu, 16 Apr 2026 07:00:00 +0000

When you start a new project on the JVM, should you pick Java or Kotlin?

Kotlin is used by Amazon, Atlassian, Duolingo, Google, JetBrains, Meta, Netflix, Uber and many more. Java is used by, well, „more than 3 billion devices“. Which one provides the biggest benefit, which one can give us an edge, which one should we pick?

After 20 years of building systems in Java and 8 years of doing the same in Kotlin, I’ve seen Kotlin earn its reputation as a natural evolution of Java. Rightfully so. Much of what we need can be expressed very cleanly with little verbosity.

BoxLang AI Deep Dive — Part 5 of 7: One API, 17 Providers — The Provider Architecture Deep Dive 🛡️

Wed, 15 Apr 2026 12:00:01 +0000

BoxLang AI 3.0 Series · Part 5 of 7

Vendor lock-in is the silent killer of AI projects. You pick OpenAI, build everything against the OpenAI API, and then GPT-5 launches at three times the price. Or a competitor launches a model that’s faster for your use case. Or you need to self-host for compliance. Or your client is on AWS and wants Bedrock.

Every time the answer to “can we switch providers?” is “it would take months,” something went wrong architecturally.

BoxLang AI Deep Dive — Part 4 of 7: Middleware — The Missing Layer in Every AI Framework 🧵

Tue, 14 Apr 2026 12:00:01 +0000

BoxLang AI 3.0 Series · Part 4 of 7

Here’s the question every team eventually asks about their AI agents: how do we test these things?

Agents make live LLM calls. They invoke real tools. They have non-deterministic outputs. Standard unit testing approaches fall apart. You can’t mock every provider. You can’t replay a conversation from three weeks ago. You can’t confidently tell stakeholders that the agent you deployed today behaves the same way it did when you signed off on it.

BoxLang AI Deep Dive — Part 3 of 7: Multi-Agent Orchestration — Building AI Teams That Work 🌲

Mon, 13 Apr 2026 12:00:01 +0000

BoxLang AI 3.0 Series · Part 3 of 7

A single agent is useful. An orchestra of agents is powerful.

The problem with most multi-agent frameworks is that the orchestration layer is bolted on — you’re managing agent references manually, passing outputs between them by hand, and hoping you haven’t introduced a cycle. There’s no concept of hierarchy. No cycle detection. No way to ask “who’s in charge here?” or “how deep in the tree am I?”

BoxLang AI Deep Dive — Part 2 of 7: Building a Production-Grade AI Tool Ecosystem

Fri, 10 Apr 2026 12:00:00 +0000

BoxLang AI 3.0 Series · Part 2 of 7

Function calling is where most AI frameworks look deceptively simple on the surface and turn into a mess underneath. You define a tool, pass it to the LLM, and when the LLM calls it — who handles the lifecycle? Who fires observability events? Who serializes the result? Who resolves the tool by name when the only thing you have is a string?

BoxLang AI Deep Dive — Part 1 of 7: The Skills Revolution 🎓

Thu, 09 Apr 2026 12:00:02 +0000

Every AI framework eventually hits the same wall: your system prompts start drifting. Agent A has a slightly different version of the SQL rules than Agent B. The tone policy on your support bot is three weeks behind the tone policy on your documentation bot. Someone copy-pasted the wrong version. Nobody noticed.

This isn’t a discipline problem: it’s an architecture problem. System prompts are plain strings, and plain strings don’t have a source of truth.

BoxLang AI v3 released - Multi-Agent Orchestration, Tooling, Skills and so much more

Tue, 07 Apr 2026 13:33:36 +0000

It’s been a while since we’ve shipped something this big. BoxLang AI 3.0 is a ground-up rethink of how AI agents, models, and tools work in the BoxLang ecosystem — and it lands with ten major features at once.

The headline is the AI Skills system: a first-class implementation of Anthropic’s Agent Skills open standard that lets you define reusable knowledge blocks: coding styles, domain rules, tone policies, API guidelines once in a SKILL.md file and inject them into any number of agents and models at runtime. No more copy-pasting the same system-prompt boilerplate everywhere. Skills are versioned, composable, and come in two modes: always-on (full content in every call) and lazy (only a name + description until the LLM asks for more).

BoxLang Spring Boot Starter: Dynamic JVM Templating for Spring

Thu, 19 Mar 2026 12:00:02 +0000

Spring Boot developers know the pain of evaluating view technologies. Thymeleaf is great — until you need more expressiveness. FreeMarker is powerful — until the syntax fights you. What if you could write templates in a dynamic JVM language that gives you the full power of the platform, feels natural, and requires zero setup to integrate?

Meet the BoxLang Spring Boot Starter.

TL;DR: Drop one dependency into your Spring Boot 3 app and start writing dynamic .bxm templates powered by BoxLang — a modern, expressive JVM language. Zero configuration. Full web scopes. 100% Java interoperable. Not only that, you get full access to BoxLang’s framework capabilities so you can integrate tons of features into your Spring Boot applications:

7 Habits of Highly Effective AI Java Coding

Thu, 12 Mar 2026 07:00:01 +0000

From AI User to AI Pro

Let’s be real, AI coding tools are everywhere now. They’re no longer some shiny new toy—they’re a part of our daily grind as developers, just like our morning coffee.

For us Java devs, whether we’re wrestling with a giant legacy app or juggling a bunch of microservices, these tools look like a huge win for getting stuff done faster.

But here’s the catch: just coding faster isn’t the whole story. If you’re not careful, it can actually lead to bigger problems down the road.

BoxLang v1.11.0 released

Tue, 10 Mar 2026 12:00:01 +0000

We’re proud to announce BoxLang 1.11.0, a highly focused performance and stability release that delivers measurable speed improvements across every BoxLang application, with zero code changes required. The team invested deeply in bytecode generation, class loading, lock management, and type casting to produce one of the most impactful runtime optimization releases to date. Alongside the performance wave, this release resolves critical concurrency bugs, hardens DateTime handling, and ships powerful new developer tooling.

Boxlang intellij ide released

Mon, 09 Mar 2026 12:51:00 +0000

The IntelliJ ecosystem is one of the most powerful development environments for JVM developers. Today, we’re excited to introduce the official BoxLang IDE plugin for IntelliJ, bringing modern BoxLang development directly into the JetBrains IDE family.

Why I Abandoned my 30-year Open Source Project

Fri, 20 Feb 2026 07:00:01 +0000

Introduction

I started an open-source project in 1996, I am abandoning now. It was not my first OSS project and certainly not the last one. It definitely was the one that lasted the longest and that I had the most faith in having an impact on the industry.

The project aimed to create a new approach to document maintenance, and over the years, I developed a few versions of software solutions that supported the idea.

Behind the Bytecode: Exploring Java Features with javap tool

Thu, 27 Nov 2025 07:00:01 +0000

When we develop applications, we often rely on a robust set of tools that the language’s development environment provides, which saves us from reinventing the wheel. In the case of Java also, the⁣ Java Development Kit (JDK) plays a vital role. It offers a comprehensive suite of tools, utilities, and commands that simplify the process of building, testing, and running Java applications, making our development faster and more efficient.

As a Java developer, I’m always fascinated by what happens behind the scenes when we compile my code into bytecode. This bytecode reveals how we represent and manage our code internally through the different components of the⁣ Java Virtual Machine (JVM). Exploring this process offers us deeper insights into Java’s architecture and helps us better understand memory management, performance, and runtime behavior.

The Rise of JVM Languages: Kotlin, Scala, Groovy, and More

Thu, 09 Oct 2025 07:00:00 +0000

Introduction

As Java marks its 30th anniversary in 2025, it remains a foundational force in software development. However, one of its most enduring contributions is not just the language itself but the Java Virtual Machine (JVM). The JVM has paved the way for numerous modern programming languages by providing a stable, efficient, and interoperable runtime environment.

Over the years, developers have embraced JVM-based languages. These languages offer alternative syntax styles, functional programming paradigms, and dynamic scripting capabilities. At the same time, they maintain seamless compatibility with Java. This article explores the growth of JVM languages. It highlights Kotlin, Scala, and Groovy, along with other influential options such as Clojure, JRuby, and Jython. These languages have extended the reach of the JVM, empowering developers with increased flexibility and productivity.

Building Local LLM AI-Powered Applications with Quarkus, Ollama, and Testcontainers

Tue, 09 Sep 2025 07:00:01 +0000

Traditionally, many AI-powered applications rely on cloud-based APIs or centralized services for model hosting and execution. While this approach has its advantages, such as scalability and ease of use, it also introduces challenges around latency, data privacy, and dependency on third-party providers.

This is where local AI models shine. By running models directly within your application’s infrastructure, you gain greater control over performance, data security, and deployment flexibility. However, building such systems requires the right tools and frameworks to bridge the gap between traditional software development and AI model integration.

Fixing the Billion-Dollar Mistake

Thu, 07 Aug 2025 07:00:00 +0000

There are mistakes that are just costly. Then there is the null reference. A language feature that was added in 1965 “simply because it was so easy to implement”. Since then, null references have caused countless bugs, system crashes and security problems - and cost billions of dollars in maintenance and troubleshooting. It has been eliminated in many new programming languages and this article will show the practical ways to eliminate this language mistake even in Java.

The long history of log4j

Tue, 10 Jun 2025 07:00:01 +0000

Logging is the art of making sense of a system.

Software writes lines of information into log files, and developers sift through them, hoping to find what they need. The problem? Systems rarely log the right things. Yet without those files, we’d be flying blind, unaware that anything even went wrong.

This is the story of Apache Log4j—one of the oldest pieces of Java code still in use today. A tool that gave developers a way to listen to their systems.

Adapting Java for Modern APIs: REST, GraphQL, and Event-Driven Innovation

Thu, 05 Jun 2025 07:00:01 +0000

Introduction

In the rapidly evolving world of software development, new API standards like REST, GraphQL, and event-driven architectures are crucial for building scalable, efficient systems. Java for modern APIs, known for its stability in enterprise applications, has continually adapted to meet the demands of these modern paradigms. With an evolving ecosystem, Java for modern APIs remains a robust choice for developers creating flexible, scalable web services.

This article explores how Java for modern APIs has evolved to support REST, GraphQL, and event-driven architectures, highlighting the technical advancements, key frameworks, and best practices that power modern API development.

Kotlin Multiplatform's Cross-Platform Brilliance at Norway's Nearly 400-Year-Old National Postal Service

Thu, 01 May 2025 08:56:32 +0000

When we think of Norway’s National Postal Service, we think of legacy, tradition, and history – a service that has been delivering letters, packages, parcels, and sometimes even joy, for nearly 400 years.\

But what happens when such an ancient institution faces the modern challenges of software development and cross-platform integration? How does a company like Posten Bring navigate the world of fragmented business logic across multiple platforms and systems?

But before I answer these questions, I want to ask YOU - Have you ever had a complex business rule-set problem? You know the kind where you have business rules (logic) spread across multiple platforms, systems, and applications? Some of them might even be alter egos of the same rule hiding in different apps. You never know which one might turn up where; there is no single source of truth, solving errors takes hours of debugging, and making changes requires (oftentimes) painful coordination across teams and applications (ugh).

We faced this exact challenge at Posten Bring As - Norwegian National Postal Service, founded way back in 1647 - a 378-year-old institution with software spanning more generations than most families! Our business logic was scattered across platforms, some of which were as ancient as the company itself (okay, maybe not that old, but close enough)!

In this article, I’m spilling the tea. We will discover how the team at a century-old Norwegian postal services giant tackled modern challenges with cutting-edge technology.

I’m going to walk you through our journey with Kotlin Multiplatform, including the hurdles we encountered, the lessons we learned, and why KMP is a game-changer for anyone grappling with similar challenges.

This article is for you if troublesome & unruly business logic keeps you up at night & you want that to end NOW. It is also for you if you like to hear a good story.

Top Security Flaws hiding in your code right now - and how to fix them

Tue, 29 Apr 2025 07:00:07 +0000

In 2019, a significant breach in Fortnite, the popular game, reportedly exposed millions of players to malware risk. The incident underscored the importance of securing SQL databases properly.

But this is not an isolated issue.

Multiple attacks involving SQL injection have occurred, like the one Tesla experienced in 2018. In that case, another SQL injection attack affected Tesla’s Kubernetes console, resulting in financial losses due to unauthorized cryptocurrency mining activities.

But this is not only about SQL Injection.

Are AI Coding tools worth it - RESULTS

Wed, 30 Oct 2024 12:32:45 +0000

Background

In Part 1 , I examined the value of AI tools for developers, especially those that help them create or understand code. The tools selected are all free to use and a mix of general-purpose ones and those that declare they are specifically for coding purposes.

In Part 2, I examined these tools’ ability to find bugs and weaknesses. The results were spotty and not particularly useful or time-saving.

In this part, we’ll look at the results from asking these tools to create JUnit tests for the code and decide who wins (and why).

Programming Language with no Syntax?

Sun, 15 Sep 2024 23:44:01 +0000

1. Introduction
Is it possible to have a programming language that has no syntax? It sounds like a contradiction. Programming languages are all about syntax, plus a bit of code generation, optimization, run-time environment, and so on. But syntax is the most important part as far as programmers are concerned. When encountering a new programming language, it takes time to learn the syntax.

Could we just make the syntax disappear or at least make it as simple as possible? Could we also make the syntax arbitrary so that the programmer writing the code can define it for themselves?

Ouroboros is a programming language that tries to do just that. It has the simplest syntax ever. It is so simple that it does not even have a syntax analyzer. All it has is a lexical analyzer, which is 20 lines long.

At the same time, you can write complex programs and even expressions with parentheses and operators of different precedence, assuming you write your own syntax for that in the program. That way, no syntax also means any syntax.

This article is an introduction to Ouroboros, a programming language with no syntax. It is a toy, never meant to be used in production, but it is a fun toy to play with, especially if you have ever wanted to create your own programming language.

There were programming languages with minimal syntax. One of the very first languages was LISP, which used only parentheses to group statements as lists.

If you are familiar with TCL, you may remember how simple the language is. However, it still defines complex expressions and control structures as part of the language.

Another simple language to mention is FORTH. It is a stack language. The syntax is minimal. You either put something on the stack or call a function that works with the values on the stack. FORTH was also famous for its minimal assembly core and for the fact that the rest of the compiler was written in FORTH itself.

These languages inspired the design of Ouroboros. LISP is known for the simplest syntax. One might say that LISP has the simplest syntax of all programming languages, but it would be a mistake. True to its name, it uses parentheses to delimit lists, which can be either data or programming structures. As you may know, LISP stands for “Lots of Irritating Superfluous Parentheses.”

Ouroboros does not do that. It inherits the use of { and } from TCL, but unlike LISP, you are forced to use them only where they are really needed.

Ouroboros, although being an interpreted language, can compile itself. Well, not really compile, but you can define syntax for the language in the language itself. However, it is not like in the case of compilers where the compiler is written in the source language. One of the first compilers was the PASCAL compiler written by Niklaus Wirth in PASCAL. The C compiler was also written in C, and more and more language compilers are written in the language they compile.

In the case of an interpreted language, it is a bit different. It is not a separate program that reads the source code and generates machine code. It is the executing code, the application program itself, that becomes part of the interpreter.

That way, you cannot look at it and say: this code is not Ouroboros. Any code can be, depending on the syntax you define for it at the start of the code.

2. The Name of the Game
Before diving into what Ouroboros is, let’s talk about the name itself. Ouroboros coils around itself in an endless cycle of creation and recreation. The name “Ouroboros” is as multifaceted as the language itself, offering layers of meaning that reflect its unique nature and aspirations.

2.1. The Eternal Cycle
At its core, Ouroboros draws inspiration from the ancient symbol of a serpent consuming its own tail. This powerful image represents the cyclical nature of creation and destruction, perfectly encapsulating our language’s self-referential definition. Just as the serpent feeds upon itself to sustain its existence, Ouroboros the language is defined by its own constructs, creating a closed loop of logic and functionality.

2.2. UR: The Essence of Simplicity
Abbreviated as “UR,” Ouroboros embraces the concept of fundamental simplicity. In German, “Ur—” signifies something primordial, primitive, or in its most basic form. This perfectly encapsulates the design philosophy behind Ouroboros: a language stripped down to its absolute essentials.

By pushing the simplification of syntax to the extreme, Ouroboros aims to be the “ur-language” of programming—a return to the most elemental form of computation. Like the basic building blocks of life or the fundamental particles of physics, Ouroboros provides a minimal set of primitives from which complex structures can emerge.

This radical simplicity is not a limitation but a feature. It challenges programmers to think at the most fundamental level, fostering a deep understanding of computational processes. In Ouroboros, every construct is essential, every symbol significant. It’s programming distilled to its purest form.

2.3. Our Shared Creation
The name begins with “Our-,” emphasizing the collaborative nature of this language. Ouroboros is not just a tool but a shared endeavor that belongs to its community of developers and users. It’s a language crafted by us, for us, evolving through our collective efforts and insights.

2.4. Hidden Treasures
Delve deeper into the name, and you’ll uncover more linguistic gems:

“Oro” in many Romance languages means “gold” or “prayer.” Ouroboros can be seen as a golden thread of logic, or a prayer-like mantra of computational thought.

“Ob-” as a prefix often means “toward” or “about,” suggesting that Ouroboros is always oriented toward its own essence, constantly reflecting upon and refining itself.

“Boros” could be playfully interpreted as a variation of “bytes,” hinting at the language’s digital nature.

Parsing the name as “our-ob-oros” reveals a delightful multilingual wordplay: “our way to the treasure.” This blend of English (“our”), Latin (“ob” meaning “towards”), and Greek (“oros,” which can be associated with “boundaries” or “definitions”) mirrors the language’s eclectic inspirations.

Just as Ouroboros draws from the diverse traditions of TCL, LISP, and FORTH, its name weaves together linguistic elements from different cultures. This multilingual, multi-paradigm approach guides us toward the treasures of computation, defining new boundaries along the way, much like how TCL offers flexibility, LISP promotes expressiveness, and FORTH emphasizes simplicity and extensibility.

2.5. A Name That Bites Back
Ultimately, Ouroboros is a name that challenges you to think recursively, to see the end in the beginning and the whole in every part. It’s a linguistic puzzle that mirrors the very nature of the programming language it represents—complex, self-referential, and endlessly fascinating.

As you embark on your journey with Ouroboros, remember that you’re not just writing code; you’re participating in an ancient cycle of creation, where every end is a new beginning, and every line of code feeds into the greater whole of computational possibility.

3. What is Ouroboros
Ouroboros is a programming language that has no syntax. I have already said that, and now comes the moment of truth: it is a “lie.” There is no programming language with absolutely no syntax. UR has a syntax, and it is defined with this sentence:

You write the lexical elements of the language one after the other.

3.1. Syntax
That is all.

When the interpreter starts to execute the code, it begins reading the lexical elements one after the other. It reads as many elements as it needs to execute some code and not more. To be specific, it reads exactly one lexical element before starting execution. When the execution triggered by the element is finished, it goes on reading the next element.

The execution itself can trigger more reads if the command needs more elements. We will see it in the next example soon.

A lexical element can be a number, a string, a symbol, or a word. Symbols and words can and should have an associated command to execute.

For example, the command puts is borrowed shamelessly from TCL and is associated with the command that prints out a string.

puts “Hello, World!”
It is the simplest program in Ouroboros. When the command behind puts starts to execute, it asks the interpreter to read the next element and evaluate it. In this example, it is a constant string, so it is not difficult to calculate. The value of a constant string is the string itself.

The next example is a bit more complex:

puts add “Hello, " “World!”
In this case, the argument to the command puts is another command: add. When puts asks the interpreter to get its argument, the interpreter reads the next element and then starts to execute. As add starts to execute, it needs two arguments, which it asks from the interpreter. Since these arguments are strings, add concatenates them and returns the result.

3.2. Blocks
There is a special command denoted by the symbol {. The lexical analyzer recognizing this character will ask the interpreter to read the following elements until it finds the closing }. This call is recursive in nature if there are embedded blocks.

The resulting command is a block command. A block command executes all the commands in it and results in the last result of the commands in the block.

puts add {“Hello, " “World!”}
If we close the two strings into a block, then the output will be a single World! without the `Hello, `. The block “executes” both strings, but the value of the block is only the second string.

3.3. Commands
The commands implemented are documented in the readme of the project on GitHub. The actual set of commands is not fascinating. Every language has a set of commands.

The fascinating part is that in UR there is no difference between functions and commands. Are puts or add commands or functions? How about if and while? They are all commands, and they are not part of the language per se. They are part of the implementation.

The command if asks the interpreter to fetch one argument, evaluated. It will use this as the condition. After this, it will fetch the next two elements without evaluation. Based on the boolean interpretation of the condition, it will ask the interpreter to evaluate one of the two arguments.

Similarly, the command while will fetch two arguments without evaluation. It then evaluates the first as a condition, and if it is true, it will evaluate the second and then go back to the condition. It fetched the condition unevaluated because it will need to evaluate it again and again. In the case of the if command, the condition is evaluated only once, so we did not need a reference to the unevaluated version.

Many commands use the unevaluated version of the arguments. This use makes it possible to use the “binary” operators as multi-argument operators. If you want to add up three numbers, you can write add add 1 2 3, or add* 1 2 3 {}, or {add* 1 2 3}. The command add fetches the first argument unevaluated and sees if it is a *. If it is *, then it will fetch the arguments until it encounters the end of the arguments or an empty block.

This is a little syntactic sugar, which should be peculiar in the case of a language that has no syntax. It really is there to make the experiment and the playing with the language bearable. On the other side, it erodes the purity of the language. It is also only a technical detail, and I mention it only because we will need to understand it when we discuss the metamorphic nature of the language. It will be needed to understand the use of the first example there.

3.4. Variables
UR supports variables. Variables are strings with values associated with them. The value can be any object.

When the interpreter sees a symbol or a bare word (identifier) to evaluate, it will check the value associated with it. If the value is a command, then it will execute the command. In other cases, it will return the value.

The variables are scoped. If you set a variable in a block, then the variable is visible only in that block. If there are variables with the same name in the parent block, then the variable in the child block will shadow the variable in the parent block.

Variable handling and scoping are implementation details and not strictly part of the language.

The implementation as it is now supports boolean, long, double, big integer, big decimal, and string primitive values. It also supports lists and objects.

A list is a list of values, and it can be created with the list command. The argument to the command is a block. The command list will ask the interpreter to fetch the argument unevaluated. Afterward, it evaluates the block from the start the same way as the block command does. However, instead of throwing away the resulting values and returning the last one, it returns a list of the results.

An object is a map of values. It can be created with the object command. The argument to the command is the parent object. The fields of the parent object are copied to the new object.

Objects also have methods. They are the fields that have a command as a value.

4. Introspection
The interpreter is open like a cracked safe after a heist. Nothing is hard-wired into the language. When I wrote that the language interpreter recognizes bare words, symbols, strings, etc., it was only true for the initial setup. The lexical analyzers implemented are UR commands, and they can be redefined. They are associated with the names $keyword, $string, $number, $space, $block, $blockClose, and $symbol. The interpreter uses the variable structures to find these commands. There is another variable named $lex that is a list of the lexical analyzers.

The interpreter uses this list when it needs to read the next lexical element. It invokes the first, then the second, and so on until one of them returns a non-null value, a lexical element, which is a command.

If you modify this list, then you can change the lexical analyzers, and that way you can change the syntax of the language.

The simplest example is changing the interpretation of the end-of-line character.

You may remember that we can use the binary operators using multiple arguments terminated with an empty block. It would be nice if we could omit the block and just write add* 1 2 3 simply adding a new-line at the end. We can do that by changing the lexical analyzer that recognizes the end-of-line character, and this is exactly what we are going to do in this example.

set q add* 3 2
1 {} puts q
insert $lex 0 ‘{
if { eq at source 0 “\n”}
{sets substring 1 length source source ‘{}}}
set q add* 3 2
1 {} puts q
We insert a new lexical analyzer at the beginning of the list. If the very first character of the current state of the source code is a new-line character, then the lexical analyzer eats this character and returns an empty block.

The command source returns the source code that was not parsed by the interpreter yet. The command sets sets the source code to the string value specified.

The first puts q will print 6 because at the time of the first calculation, new-lines are just ignored, and that way the value of q is add* 3 2 1 {}. The second puts q will print 5 because the new-line is eaten by the lexical analyzer, and the value of q is add* 3 2 {}. Here, the closing {} was the result of the lexical analysis of the new-line character. The values 1 and {} on the next line are calculated, but they do not have any effect.

This is a very simple example. If you want to see something more complex, the project file src/test/resources/samples/xpression.ur contains a script that defines a numerical expression parser.

There is a special command called fixup. This command forces the interpreter to parse the rest of the source. After this point, the lexical analyzers are not used anymore.

Executing this command does not give any performance benefit, and that is not the purpose. It is more like a declaration that all the codes that are part of the source code introspection and the metamorphic calculation are done. A special implementation of the command can also take the parsed code and generate an executable, turning the interpreter into a compiler.

5. Technical Considerations
The current version is implemented in Java. Ouroboros is not a JVM language, though. We do not compile the code to Java byte-code. The Java code interprets the source and executes it.

The implementation is an MVP focusing on the metamorphic nature of the language. It is meant to be an experiment. This is the reason why there are no file, network, and other I/O operations except the single puts command that writes to the standard output.

The Java service loader feature is used to load the commands and to register them with their respective names in the interpreter. It means that implementing extra commands is as simple as creating them, writing a class implementing a ContextAgent to register them (see the source code), and putting them on the classpath.

The whole code is open-source and available on GitHub. It is licensed under the Apache License 2.0 (see the license file in the repo). It is exactly 100 classes at the time of writing this article. It means that the source code is simple, short, and easy to understand. If you need some straightforward scripting language in your application, you can use it. It was not meant to be for production, though.

6. Going Further
There is no plan currently to extend the language and include more commands. We only plan to create more metamorphic code in the language. The reason for that is that we do not see the language as a practical tool as of today. If it proves to be useful and gains a user base and utilization, we certainly will incorporate more commands to support I/O, file handling, networking, and so on.

We also have visions of implementing the interpreter in other languages, like in Rust and Go. Anyone suggesting or wanting to develop commands for better usability or adding features is welcome. It can be a parallel project, or it can be merged into the main project if that makes sense.

7. Conclusion
In exploring Ouroboros, we delved into the concept of a programming language that minimizes syntax to the point of almost non-existence. This radical approach challenges the conventional understanding of what a programming language should be, presenting a system where syntax is both absent and infinitely customizable. By drawing inspiration from languages like LISP, TCL, and FORTH, Ouroboros embodies simplicity and introspection, allowing programmers to define their syntax and commands within the language itself.

While Ouroboros is not designed for practical production use, it serves as an intriguing experiment in language design and metaprogramming. Its self-referential nature and minimalistic design offer a playground for developers interested in the fundamentals of computation, syntax design, and language interpretation. Whether it evolves into a more robust tool or remains a fascinating intellectual exercise, Ouroboros pushes the boundaries of how we think about programming languages, inviting us to consider the possibility of a language where syntax is as mutable and recursive as the Ouroboros serpent itself.

JVM Languages on JAVAPRO International

BoxLang’s First 11 Months: Explosive Growth, Developer Empowerment, and the Return of Dynamic Language!

BoxLang 1.14.0 : Query Transformers: Take Full Control of Your Query Results

BoxLang 1.14.0 : Introducing Inner Classes

BoxLang 1.14.0 : BoxSet is Here: BoxLang's New First-Class Set Type

BoxLang 1.14.0 : Sets, Ranges, Inner Classes, and a Runtime That Talks Back

Introducing bx-jwt: Enterprise-Grade JSON Web Tokens for BoxLang

Introducing BoxLings! An interactive teacher for BoxLang and TDD/BDD

BoxLang v1.13.0: Compatibility, Concurrency, and Formatter Maturity

BoxLang Goes Serverless on Google Cloud

The Architecture

Build Cross-Platform Desktop Apps with BoxLang

BoxLang AI 3.2.0 — Image Generation, Web Search, Fluent Audio, Agent Registry & MCP Observability

🖼️ Image Generation — aiImage()

Introducing skills.boxlang.io — The Open Agent Skills Ecosystem for BoxLang & the Ortus World

Announcing MatchBox Open Beta: BoxLang, Now Running in New Places

Kotlin kontra Java - Part 3 - Language for Interop

Kotlin kontra Java - Part 2 - MultiPlatform

How to Develop AI Agents Using BoxLang AI: A Practical Guide

BoxLang AI Deep Dive — Part 7 of 7: MCP — The Protocol That Connects Everything 🔌

BoxLang AI Deep Dive — Part 6 of 7: Memory Systems & RAG — Building AI That Remembers 🧠

Kotlin kontra Java - Part 1 - Ecosystem

BoxLang AI Deep Dive — Part 5 of 7: One API, 17 Providers — The Provider Architecture Deep Dive 🛡️

BoxLang AI Deep Dive — Part 4 of 7: Middleware — The Missing Layer in Every AI Framework 🧵

BoxLang AI Deep Dive — Part 3 of 7: Multi-Agent Orchestration — Building AI Teams That Work 🌲

BoxLang AI Deep Dive — Part 2 of 7: Building a Production-Grade AI Tool Ecosystem

BoxLang AI Deep Dive — Part 1 of 7: The Skills Revolution 🎓

BoxLang AI v3 released - Multi-Agent Orchestration, Tooling, Skills and so much more

BoxLang Spring Boot Starter: Dynamic JVM Templating for Spring

7 Habits of Highly Effective AI Java Coding

From AI User to AI Pro

BoxLang v1.11.0 released

Boxlang intellij ide released

Why I Abandoned my 30-year Open Source Project

Introduction

Behind the Bytecode: Exploring Java Features with javap tool

The Rise of JVM Languages: Kotlin, Scala, Groovy, and More

Introduction

Building Local LLM AI-Powered Applications with Quarkus, Ollama, and Testcontainers

Fixing the Billion-Dollar Mistake

The long history of log4j

Adapting Java for Modern APIs: REST, GraphQL, and Event-Driven Innovation

Introduction

Kotlin Multiplatform's Cross-Platform Brilliance at Norway's Nearly 400-Year-Old National Postal Service

Top Security Flaws hiding in your code right now - and how to fix them

Are AI Coding tools worth it - RESULTS

Background

Programming Language with no Syntax?

🖼️ Image Generation — `aiImage()`