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.

What Is BoxLings?

BoxLings gives you 129 progressive exercises across 28 topics — from the basics of variables and functions all the way to async programming, Java interop, destructuring, and CLI app development.

But here's what makes BoxLings different: we teach TDD/BDD as a first-class skill, not an afterthought, using TestBox; our BDD/TDD testing library.

From day one, you'll read TestBox specs before touching any implementation code. You'll learn to think in tests. By the time you hit the intermediate exercises, you'll be writing your own. By Phase 3, you'll be doing the full red-green-refactor cycle like a pro.

The Full Learning Path

BoxLings is organized into three progressive phases, with 28 topics and 129 exercises total.

🟢 Phase 1 — Core Fundamentals (50 Exercises)

Perfect for beginners and developers new to BoxLang:

🟡 Phase 2 — Intermediate (40 Exercises)

Dive deeper into BoxLang's power features:

🔴 Phase 3 — Advanced (48 Exercises)

Master BoxLang-specific and power-user features:

The TDD/BDD Learning Journey

BoxLings teaches test-driven development alongside BoxLang in four progressive stages:

Step 1 — Reading Tests (Topics 1–10)
Read TestBox specs to understand requirements. Tests are your documentation.

Step 2 — Understanding Patterns (Topics 11–14)
Multiple assertions, setup/teardown with beforeEach/afterEach, edge cases, and error scenarios.

Step 3 — Writing Tests (Topic 15)
Now you write the specs. Practice describe / it / expect from scratch.

Step 4 — Full TDD Cycle (Topics 16–29)
Red → Green → Refactor. The real deal.

How It Works

git clone https://github.com/ortus-boxlang/boxlings.git
cd boxlings
boxlang BoxLings.bx

BoxLings drops you into watch mode — it monitors your exercise files and reruns them automatically every time you save. Fix the code, hit save, see the tests go green.

Keyboard shortcuts in watch mode:

Three exercise types are supported: scripts (.bxs), classes (.bx), and templates (.bxm), covering the full breadth of how BoxLang is used in practice.

Built for Learners, Classrooms & Workshops

BoxLings is self-contained and runs completely offline after the initial clone. Whether you're learning solo, teaching a workshop, or onboarding a new team member, BoxLings provides a structured, guided path with immediate feedback.

Estimated completion time:

• 🆕 Beginners: ~15–20 hours
• 💻 Experienced developers new to BoxLang: ~6–10 hours
• 🔥 Java developers: ~4–6 hours

Get Started

You'll need BoxLang 1.12+. We recommend BVM to manage your BoxLang versions:

curl -fsSL https://install-bvm.boxlang.io/ | bash
bvm install 1.12.0
bvm use 1.12.0

Then clone and go:

git clone https://github.com/ortus-boxlang/boxlings.git
cd boxlings
boxlang BoxLings.bx

Join the Community

We'd love to hear what you think — and contributions are very welcome. New exercises, bug fixes, documentation — all of it.

• 📖 BoxLang Docs
• 💬 Community Forum
• 🤝 BoxLang Slack
• 🐛 Open an Issue

👉 github.com/ortus-boxlang/boxlings

Now go fix some broken code. 🥊

The post Introducing BoxLings! An interactive teacher for BoxLang and TDD/BDD appeared first on foojay.

The Headline: AI Skills System Brand New Docs MCP Server Seeding Global AI Tool Registry Tool System Overhaul Provider Capability System Parent-Child Agent Hierarchy Middleware Support Stateless Agents + Per-Call Identity RoutingWhat Else Is NewNo Breaking ChangesGet Started

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).

But that's just the start. Here's everything landing in 3.0:

• 🎯 AI Skills System — composable, file-based knowledge blocks injected into any agent or model at runtime
• 🔌 MCP Server Seeding — agents auto-discover and register tools from any MCP server
• 🗄️ Global AI Tool Registry — register tools by name once, reference them as strings anywhere
• 🔧 Tool System Overhaul — new BaseTool / ClosureTool architecture plus two built-in core tools
• 🛡️ Provider Capability System — type-safe capability detection with clear UnsupportedCapability errors
• 🌲 Parent-Child Agent Hierarchy — multi-agent orchestration trees with cycle detection and depth tracking
• 🧵 Middleware Support — six built-in middleware classes for logging, retries, guardrails, and more
• 🏢 Stateless Agents + Per-Call Identity Routing — safe multi-tenant memory across concurrent requests
• 🤗 HuggingFace Embeddings — new provider for the HuggingFace Inference API
• 🔀 Custom Service URLs — proxy and self-hosted endpoint support across all providers

Read the full changelog here: https://ai.ortusbooks.com/readme/release-history/3.0.0

If you've been building AI-powered apps with BoxLang, this release changes everything. If you haven't started yet, this is the release that makes it worth it.

Let's dig in. 🎉

🎯 The Headline: AI Skills System

The single biggest addition in 3.0 is the AI Skills system — a first-class implementation of Anthropic's Agent Skills open standard.

Think of a skill as a portable, reusable unit of expertise: a SQL coding style guide, a tone-of-voice policy, domain-specific rules, API cheat sheets — anything your AI should know before it starts answering. Define it once in a SKILL.md file. Inject it into any number of agents and models at runtime. No more copy-pasting the same system-prompt boilerplate across every agent you build.

// Load a skill from a file
apiSkill = aiSkill( ".ai/skills/api-guidelines/SKILL.md" )

// Load every skill in a directory tree
allSkills = aiSkill( ".ai/skills/", recurse: true )

// Inline skill for short, self-contained guidance
sqlStyle = aiSkill(
    name        : "sql-style",
    description : "SQL coding standards",
    content     : "Always use snake_case. Prefer CTEs. Never use SELECT *."
)

Skills come in two injection modes:

• Always-on — full content in every LLM call. Zero latency. Best for short, universally relevant rules like tone and formatting.
• Lazy — only a name + one-line description goes into the system message. The LLM calls a built-in loadSkill( name ) tool to fetch the full content on demand. Perfect for large skill libraries where most skills are irrelevant to most queries — keeps your token usage low.

You can even promote a lazy skill to always-on mid-session:

// After the user mentions SQL work, pre-load it for the rest of the conversation
agent.activateSkill( "sql-style" )

And if you want certain skills available to every agent in your application without explicitly passing them:

// In Application.bx — every agent inherits these automatically
aiGlobalSkills().add( aiSkill( ".ai/skills/company-tone/SKILL.md" ) )
aiGlobalSkills().add( aiSkill( ".ai/skills/security-policy/SKILL.md" ) )

Skills live in plain Markdown files — which means your team can review them in pull requests, diff them, and keep them in sync with the rest of your codebase. This is the end of prompt drift.

📚 Brand New Docs

The entire documentation has been re-organized so you can go from zero to hero. Tons of new sections and more direct docs for your reading pleasure: https://ai.ortusbooks.com/

🔌 MCP Server Seeding

Agents can now be pointed directly at one or more MCP servers. All tools exposed by those servers are discovered automatically via listTools() and registered as MCPTool instances — no manual tool construction required.

agent = aiAgent(
    name       : "data-analyst",
    mcpServers : [
        { url: "http://localhost:3001", token: "secret" },
        "http://internal-tools-server:3002"
    ]
)

Or fluently:

agent = aiAgent( "analyst" )
    .withMCPServer( "http://localhost:3001", { token: "secret" } )
    .withMCPServer( mcpClientInstance )

The agent's system prompt is automatically updated so the LLM knows which tools came from which server. MCP servers are also surfaced in getConfig() output for full observability.

🗄️ Global AI Tool Registry

New in 3.0: a module-scoped Global Tool Registry accessible via the aiToolRegistry() BIF. Register tools by name once — in Application.bx or ModuleConfig.bx — and reference them as plain strings anywhere in your codebase.

// Register once
aiToolRegistry().register( "searchProducts", productSearchTool )
aiToolRegistry().register( "getWeather@myapp", weatherTool )

// Reference by name anywhere — no live object references needed
result = aiChat(
    "Find wireless headphones under $50",
    { tools: [ "searchProducts", "getWeather@myapp" ] }
)

Module namespacing (e.g. now@bxai) keeps registrations collision-free across modules. Two new interception points — onAIToolRegistryRegister and onAIToolRegistryUnregister — give you hooks for auditing and lifecycle management.

🔧 Tool System Overhaul

The tool system has been significantly redesigned around a new BaseTool abstract base class. All tool implementations extend it, getting the shared invocation lifecycle, result serialization, and fluent describeArg() annotation syntax for free.

The old Tool.bx is replaced by ClosureTool — a BaseTool subclass backed by any closure or lambda that auto-introspects the callable's parameter metadata to generate an OpenAI-compatible function schema.

searchTool = aiTool(
    "searchKB",
    "Search the knowledge base",
    function( required string query, numeric maxResults = 5 ) {
        return knowledgeBase.search( query, maxResults )
    }
)

Two built-in core tools ship with the module:

• now@bxai — auto-registered on module load, returns the current date/time in ISO 8601. Every agent gets temporal awareness for free, with no configuration.
• httpGet — opt-in only (not auto-registered for security), fetches any URL via HTTP GET.

now@bxai being auto-registered is worth calling out. No major AI framework ships built-in tools out of the box. This is a genuine differentiator — your agents just know what time it is without any wiring on your part.

🛡️ Provider Capability System

A new type-safe capability system prevents calling unsupported operations on providers and gives you clear, actionable errors instead of cryptic runtime crashes.

service = aiService( "voyage" )
println( service.getCapabilities() )          // [ "embeddings" ]
println( service.hasCapability( "chat" ) )    // false

aiChat(), aiChatStream(), and aiEmbed() now check provider capabilities before calling and throw a clean UnsupportedCapability exception if the requirement isn't met. No more debugging mysterious provider errors.

🌲 Parent-Child Agent Hierarchy

Multi-agent orchestration is now a first-class concept. AiAgent tracks its position in an agent tree with full introspection, cycle detection, and depth tracking.

coordinator = aiAgent( name: "coordinator" )
    .addSubAgent( aiAgent( name: "researcher" ) )
    .addSubAgent( aiAgent( name: "writer" ) )

println( coordinator.isRootAgent() )         // true
println( researcherAgent.getAgentDepth() )   // 1
println( writerAgent.getAgentPath() )        // /coordinator/writer
println( researcherAgent.getAncestors() )    // [ coordinator ]

addSubAgent() automatically wires the parent relationship. getConfig() exposes parentAgent, agentDepth, and agentPath for full observability.

🧵 Middleware Support

Both AiModel and AiAgent now support composable middleware for cross-cutting concerns — logging, retries, guardrails, human-in-the-loop approvals, and more. Agent middleware is prepended ahead of model middleware in the execution chain.

3.0 ships six middleware classes out of the box:

The FlightRecorderMiddleware deserves a special mention — it's a testing superpower. Record a live agent run once, commit the fixture, and replay it deterministically in CI with zero live provider calls.

// Record a real run
agent = aiAgent( "weather-bot", middleware: new FlightRecorderMiddleware( mode: "record" ) )
agent.run( "What is the weather in London?" )
// → Writes: .ai/flight-recorder/weather-bot-<timestamp>.json

// Replay in CI — no live calls, fully deterministic
agent = aiAgent(
    "weather-bot",
    middleware: new FlightRecorderMiddleware(
        mode        : "replay",
        fixturePath : "tests/fixtures/weather-bot.json"
    )
)

🏢 Stateless Agents + Per-Call Identity Routing

AiAgent is now fully stateless. userId and conversationId are resolved per-call from the options argument, eliminating shared-state concurrency bugs in multi-user deployments.

Every memory type (IAiMemory, IVectorMemory) now accepts optional userId and conversationId on add(), getAll(), clear(), and related methods — so a single memory instance can safely serve multiple tenants:

sharedMemory = aiMemory( "cache" )

sharedMemory.add( message, userId: "alice", conversationId: "conv-1" )
sharedMemory.add( message, userId: "bob",   conversationId: "conv-2" )
sharedMemory.getAll( userId: "alice", conversationId: "conv-1" )

What Else Is New

• 🤗 HuggingFace Embeddings — new huggingface provider for the HuggingFace Inference API
• 🔀 Custom Service URLs — all senders now accept a baseUrl override for proxies, self-hosted endpoints, and OpenAI-compatible APIs
• 🏗️ BaseService → OpenAIService split — BaseService is now truly provider-agnostic, making custom provider implementations much cleaner
• 🐛 Streaming event fixes — beforeAIModelInvoke/afterAIModelInvoke events were not firing for streaming; fixed
• 🐛 MCP requestId null crash — fixed a crash on JSON-RPC notifications that intentionally omit id

No Breaking Changes

3.0 is a major release but your existing code keeps working. aiChat(), aiEmbed(), and aiAgent() BIF signatures are unchanged. Upgrade, run your tests, and start exploring the new APIs.

Get Started

# Install or upgrade your OS installation via BoxLang
install-bx-module bx-ai

# Install or upgrade via CommandBox
install bx-ai

📖 Full Documentation
🛠️ Changelog
🐛 Report Issues
💬 Community Slack

The post BoxLang AI v3 Has Landed – Multi-Agent Orchestration, Tooling, Skills and so much more appeared first on foojay.

Houston, Texas – January 2025 – Ortus Solutions, a leading innovator in professional open-source development, today announced the release of BoxLang 1.9.0, a major stability and compatibility release focused on production-readiness. This release resolves over 50 critical bugs and introduces significant enhancements to datasource management, context lifecycle handling, and web form processing for mission-critical enterprise applications.

Production-Ready Enhancements

BoxLang 1.9.0 delivers critical improvements based on real-world client migrations and production deployments:

• Elimination of Connection Leaks: Complete datasource lifecycle management eliminates connection pool exhaustion across application restarts
• Memory Leak Prevention: Enhanced context cleanup with proper thread tracking and resource disposal
• Modern Web Standards: Automatic array-based form field parsing using contemporary naming conventions
• Enterprise Database Support: Comprehensive Oracle, MySQL, and PostgreSQL improvements including named parameters, ref cursors, and query-of-queries enhancements
• Fluent SOAP Integration: Enhanced SOAP client with automatic WSDL discovery and intelligent type conversion

Key Features and Code Examples

Array-Based Form Field Parsing

BoxLang now automatically parses query parameters and form fields as arrays using modern naming conventions:

// HTML form with multiple selections
<form method="POST">
    <input type="checkbox" name="colors[]" value="red" />
    <input type="checkbox" name="colors[]" value="blue" />
    <input type="checkbox" name="colors[]" value="green" />
    <button type="submit">Submit</button>
</form>

Then it can read them when submitted:

// BoxLang automatically parses as array
selectedColors = form.colors;
// Result: ["red", "blue", "green"]

// Works with query parameters too
// URL: /page?tags[]=boxlang&tags[]=java&tags[]=modern
tags = url.tags;
// Result: ["boxlang", "java", "modern"]

Datasource Lifecycle Management

Critical fixes prevent connection pool leaks and resource exhaustion:

class {
    this.name = "MyApp";

    this.datasources = {
        "mydb" : {
            driver : "mysql",
            host : "localhost",
            database : "appdb",
            username : "user",
            password : "pass"
        }
    };

    function onApplicationEnd() {
        // Datasources properly shutdown automatically
        // No more connection pool leaks!
        writeLog( "Datasources cleaned up automatically" );
    }
}

Oracle Database Improvements

Named parameters and ref cursors now work correctly:

// Named parameters work correctly
queryExecute(
    "SELECT * FROM users WHERE id = :userId AND status = :status",
    {
        userId : { value : 123, type : "integer" },
        status : { value : "active", type : "varchar" }
    },
    { datasource : "oracle_ds" }
);

// Ref cursor parameters work regardless of position
bx:storedproc procedure="getUserData" datasource="oracle_ds" {
    bx:procparam type="in" value=123 type="integer";
    bx:procparam type="out" variable="result" type="refcursor";
}

Enhanced SOAP Client with Fluent API

BoxLang 1.9.0 includes major enhancements to the SOAP client introduced in 1.8.0, now with full class capabilities and improved reliability:

// Create SOAP client with fluent configuration
ws = soap( "http://api.example.com/service.wsdl" )
    .timeout( 60 )
    .withBasicAuth( "apiuser", "apipass" )
    .header( "X-API-Key", "your-key" );

// Invoke operations with automatic type conversion
result = ws.invoke( "GetCustomer", { customerId: 123 } );

// SOAP client now has full class structure
ws.setTimeout( 30 );
ws.setHeader( "Authorization", "Bearer token123" );

// Inspect available operations programmatically
operations = ws.getOperationNames();
if ( ws.hasOperation( "ProcessOrder" ) ) {
    order = ws.invoke( "ProcessOrder", orderData );
}

Key SOAP Improvements:

• Automatic WSDL Discovery: Parses operations, parameters, and types automatically
• Intelligent Type Conversion: SOAP XML types automatically become BoxLang types
• Full Class Capabilities: Access underlying HTTP methods and configuration
• Operation Inspection: Programmatically discover and validate operations
• Enhanced Reliability: Improved error handling and connection management

Technical Specifications

50+ Critical Bug Fixes including:

• 15+ CFML compatibility fixes for customers migrating from CFML to Boxlang (ListDeleteAt, ListAppend, Boolean strings, Session IDs)
• Enhanced file operations and upload handling
• Date/time parsing improvements with speed improvements of over 60% of previous releases
• Session and cookie management fixes
• Core runtime optimizations
• Database and ORM enhancements
• Memory and threading improvements
• Number handling and JSON serialization enhancements

The complete engineering release notes are available at:

Availability and Licensing

BoxLang 1.9.0 is available immediately for download at with installation guides at

BoxLang operates under a transparent three-tier licensing model:

• BoxLang (Apache 2.0): Free, open-source core
• BoxLang+: Commercial features with support
• BoxLang++: Enterprise features and support

All tiers feature straightforward pricing with no hidden fees or complex calculation models.

About BoxLang

BoxLang is a modern, dynamic, multi-runtime JVM language and productivity framework. With it's multi-parser architecture it can be also used to run CFML applications. Backed by Ortus Solutions’ 20 years of professional open-source expertise, BoxLang delivers enterprise-grade reliability for mission-critical applications.

About Ortus Solutions

Ortus Solutions is a leading provider of professional open-source software with two decades of experience in enterprise application development. The company specializes in JVM languages, web frameworks, and modern development tooling for Fortune 500 companies and government agencies.

https://www.boxlang.io
https://www.ortussolutions.com

Learn More:

• Website: https://boxlang.io
• Documentation: https://boxlang.ortusbooks.com
• Try Online: https://try.boxlang.io
• Subscription Plans: https://boxlang.io/plans

The post BoxLang 1.9.0 Released: Production-Ready Stability and Enterprise-Grade Reliability appeared first on foojay.

Couchbase + BoxLang: A High-Performance Combination Enterprise-Grade Distributed Caching True Distributed Locking for Mission-Critical Workloads

• Component-Based Locking (Recommended)
• Callback-Based Locking

AI Vector Memory for BoxLang Agents

• Example: Persistent Vector-Powered Memory
• Multi-Tenant Isolation
• Hybrid Memory Model

Direct Couchbase SDK Access Session Storage Backed by Couchbase

• Installation
• Quick App Configuration
• E-Commerce Inventory Protection
• AI-Powered Customer Support
• Financial Transaction Processing

Ortus Solutions is thrilled to announce the official release of bx-couchbase v1.0, a groundbreaking module that brings native enterprise-grade Couchbase capabilities to the BoxLang language and ecosystem. Designed for modern distributed applications, bx-couchbase unifies high-performance caching, resilient distributed locking, and advanced AI vector memory—empowering developers to build scalable, intelligent, fault-tolerant systems with unprecedented ease.

Couchbase + BoxLang: A High-Performance Combination

Couchbase is more than a database—it’s a distributed NoSQL platform engineered for speed, flexibility, and global scale. With sub-millisecond key-value operations, built-in vector search, and multi-data-center support, it is the ideal foundation for next-generation AI-powered applications.

The new bx-couchbase v1.0 module exposes all this power through an elegant, intuitive, and fully integrated BoxLang API. Not only that, it is fully documented.

📘 Documentation:
https://boxlang.ortusbooks.com/boxlang-framework/boxlang-plus/modules/bx-couchbase

WHAT’S IN bx-couchbase v1.0

🚀 Enterprise-Grade Distributed Caching

bx-couchbase introduces a complete cache provider with replication, fault tolerance, TTL support, scopes, and collections—all optimized for BoxLang. You can easily leverage any bucket, scope or collection as a BoxLang native Cache, even store all your session scope and distribute it.

cache("default").set("user:123", {
    name: "Alice Smith",
    email: "alice@example.com",
    role: "admin"
} )

user = cache("default").get("user:123")
    .orElseGet( () => loadUserFromDatabase(123) )

Highlights:

• Sub-millisecond read/write operations
• Automatic replication and failover
• Built-in TTL support
• Logical grouping via scopes & collections
• First-class integration with BoxLang caching APIs

🔐 True Distributed Locking for Mission-Critical Workloads

bx-couchbase v1.0 delivers robust distributed locking—ideal for financial transactions, inventory control, batch operations, and high-traffic systems. It has introduced a semantic component to give you locking capabilities into Couchbase. You can also use the functional approach as well.

Component-Based Locking (Recommended)

bx:couchbaseLock
    name="payment-#orderId#"
    cache="default"
    timeout="5"
    expires="30"{

    charge = getPaymentInfo( orderId )
    result = processCharge( charge )
    updateOrderStatus( orderId, "paid" )

}

Callback-Based Locking

result = couchbaseLock(
    cacheName = "default",
    name = "inventory-#productId#",
    timeout = 5,
    expires = 30,
    callback = () => {
        stock = getStock( productId )
        if (stock.quantity >= orderQty) {
            stock.quantity -= orderQty
            saveStock(productId, stock)
            return { success: true }
        }
        return { success: false, error: "Insufficient stock" }
    }
)

Real-World Use Cases:

• 💰 Payment processing
• 📦 Inventory control
• 🔄 Batch job coordination
• 👤 Serialized user updates
• 🎫 Ticketing & reservation systems

🤖 AI Vector Memory for BoxLang Agents

A major highlight of v1.0 is deep integration with the bx-ai v2 module, enabling Couchbase-backed vector memory for AI agents, chatbots, and RAG pipelines.

Example: Persistent Vector-Powered Memory

memory = aiMemory( "cache", {
    cacheName: "couchbase_ai_memory",
    scope: "ai",
    collection: "conversations",
    embeddingProvider: "openai",
    embeddingModel: "text-embedding-3-small"
})

agent = aiAgent(
    name: "Customer Support Bot",
    instructions: "You are a helpful customer support agent",
    memory: memory,
    model: aiModel( "openai" )
);

response = agent.run( "What did we discuss about billing?" )

Multi-Tenant Isolation

Each user and conversation remains fully isolated:

aliceMemory = aiMemory( "cache",
    userId: "alice",
    conversationId: "support-123",
    config: { cacheName: "ai_memory" }
)

Hybrid Memory Model

Combine short-term recency + long-term semantic search:

memory = aiMemory( "hybrid", {
    window: { type: "windowed", size: 10 },
    vector: {
        type: "cache",
        cacheName: "ai_memory",
        limit: 5
    }
})

AI Features:

• Meaning-based semantic search
• User & conversation isolation
• Persistent, scalable vector storage
• Hybrid search models
• Support for OpenAI, Cohere, Voyage & more

🛠️ Direct Couchbase SDK Access

For advanced use cases, developers can directly access Couchbase Java SDK primitives but with many dynamic features and automatic serialization/deserialization, and casting.

cluster = couchbaseGetCluster("default")
collection = couchbaseGetCollection("default")

result = collection.query("
    SELECT * FROM myapp
    WHERE type = 'user'
    LIMIT 100
")

📦 Session Storage Backed by Couchbase

// Application.bx
this.sessionStorage = "couchbase"

session.user = userObject;

PERFORMANCE & SCALING

• Sub-millisecond KV speed
• Automatic sharding
• Replication & HA built-in
• Memory-first architecture
• Global multi-cluster support

GETTING STARTED

Install BoxLang OS, or chose a web runtime, then install the couchbase module. (www.boxlang.io)

Installation

install-bx-module bx-couchbase
# or
box install bx-couchbase

Quick App Configuration

this.caches[ "default" ] = {
    provider: "Couchbase",
    properties: {
        connectionString: "couchbase://localhost",
        username: "Administrator",
        password: "password",
        bucket: "myapp",
        scope: "_default",
        collection: "_default"
    }
}

REAL-WORLD APPLICATIONS

E-Commerce Inventory Protection

function reserveProduct( productId, quantity ) {
    return couchbaseLock(
        cacheName = "default",
        name = "inventory-#productId#",
        timeout = 5,
        expires = 10,
        callback = () => { ... }
    )
}

AI-Powered Customer Support

agent = aiAgent(...)
return agent.run(message)

Financial Transaction Processing

couchbaseLock("default", "payment-#orderId#", 5, 30, () => { ... })

JOIN THE COMMUNITY

• 📘 Docs: https://boxlang.ortusbooks.com/boxlang-framework/boxlang-plus/modules/bx-couchbase
• 🐞 Issues: https://ortussolutions.atlassian.net
• 💬 Community Forum: https://community.ortussolutions.com
• 💼 Support: https://www.boxlang.io/plans#open-source

The post BoxLang CouchBase Module: Enterprise Caching, Distributed Locking, and AI Vector Memory appeared first on foojay.

Dynamic JVM Language Adds Server-Sent Events, JDBC Cache Store, and AST Generation Capabilities

Houston, TX – November 7, 2025 – Ortus Solutions announced the release of BoxLang 1.7.0, a major update to its modern dynamic language for the JVM that delivers enterprise-grade capabilities for building real-time, horizontally scalable, and AI-driven applications.

This release introduces native Server-Sent Events (SSE) for real-time streaming, JDBC-powered distributed caching, Abstract Syntax Tree (AST) programmatic access, and bytecode compatibility versioning—alongside extensive performance optimizations across the runtime.

Real-Time Streaming with Server-Sent Events

The centerpiece of this release is full Server-Sent Events (SSE) integration via a new SSE() built-in function and an enhanced Emitter system. These additions empower developers to build real-time, event-driven applications such as AI chatbots, live analytics dashboards, progress streams, and notification services.

Version 1.8 will extend this with an upcoming SSEConsumer() API, enabling runtime-to-runtime event consumption for distributed systems.

// Stream analytics data in real time
SSE(
    callback : ( emitter ) => {
        var startTime = now();
        while ( !emitter.isClosed() && dateDiff( "s", startTime, now() ) < 300 ) {
            emitter.send({
                activeUsers : getActiveUserCount(),
                requestsPerSecond : getCurrentRPS(),
                avgResponseTime : getAvgResponseTime(),
                timestamp : now()
            }, "metrics");
            sleep(5000);
        }
        emitter.close();
    },
    async : true,
    keepAliveInterval : 15000
);

The implementation includes async execution, automatic keep-alive, client disconnect detection, CORS support, and automatic chunking for messages exceeding 32KB—ensuring efficient, resilient streaming at scale.

// Stream AI responses token by token
SSE(
    callback : ( emitter ) => {
        var response = callAIService();
        while ( !emitter.isClosed() && response.hasMoreTokens() ) {
            emitter.send( response.getNextToken(), "token" );
        }
        emitter.send({ complete : true }, "done");
    },
    async : true,
    keepAliveInterval : 30000,
    timeout : 300000
);

Enterprise-Ready Distributed Caching

BoxLang 1.7.0 debuts the JDBC Cache Store, a robust distributed caching solution that enables shared caches across multiple BoxLang instances using enterprise databases such as Oracle, MySQL, PostgreSQL, Microsoft SQL Server, Apache Derby, HSQLDB, and SQLite.

// boxlang.json
{
  "caches": {
    "distributedCache": {
      "provider": "BoxCache",
      "properties": {
        "objectStore": "JDBCStore",
        "datasource": "myDatasource",
        "table": "boxlang_cache",
        "autoCreate": true,
        "maxObjects": 1000,
        "evictionPolicy": "LRU"
      }
    }
  }
}

The JDBC store includes automatic schema creation, database-specific SQL optimization, eviction policy support (LRU, LFU), and Base64 object serialization for complex types. All cache stores now implement isDistributed() for ecosystem introspection.

Advanced Code Analysis with BoxAST()

Developers can now access BoxLang’s internal Abstract Syntax Tree through the new BoxAST() built-in function. This feature supports the creation of linters, formatters, migration tools, and refactoring utilities—making it invaluable for static analysis and CFML-to-BoxLang transitions.

// Parse BoxLang code
ast = BoxAST( source : "x = 1 + 2; y = x * 3;" );

// Or use the convenient member method
ast = "function hello() { return 'world'; }".toAST();

// Parse from files
ast = BoxAST( filepath : "myScript.bx" );

// Return as JSON for external tools
astJson = BoxAST(
    source : "function hello() { return 'world'; }",
    returnType : "json"
);

// Parse CFML code for migration tools
cfAst = BoxAST(
    source : "<cfset x = 1><cfoutput>#x#</cfoutput>",
    sourceType : "cftemplate"
);

BoxAST() supports BoxLang script and template syntax, as well as CFML/ColdFusion code parsing for migration purposes, returning structured, JSON, or text output.

Bytecode Compatibility Versioning

To enhance module stability and cross-version reliability, BoxLang now implements bytecode compatibility versioning, ensuring that compiled artifacts remain consistent and reusable across multiple runtime releases—a major improvement for module authors and enterprise teams maintaining large applications.

Performance & Stability Enhancements

Version 1.7.0 delivers substantial runtime performance boosts, including:

• ⚡ Faster Scheduled Tasks via optimized concurrent maps
• 🚀 Improved Static Initializers for class loading
• 💾 Optimized ASM Bytecode Generation eliminating intermediate disk writes
• 🔁 Cache Store Enhancements across all providers

Additionally, over 40 bug fixes improve database interaction, file handling, HTTP services, CFML compatibility, and Windows platform support.

Open and Professional Ecosystem

BoxLang follows a professional open-source model with three editions: Open Source (Apache 2.0), BoxLang+, and BoxLang++.
The open-source core remains free, while commercial tiers provide support, advanced modules, and enterprise tooling—licensed fairly based on usage, not infrastructure.

New BoxLang+ exclusive modules include:

• 🧠 bx-redis – High-performance Redis integration
• 📊 bx-csv – Advanced CSV processing
• 🔐 bx-ldap – LDAP directory services
• 📈 bx-spreadsheet – Excel file operations
• 📄 bx-pdf – PDF generation

Future roadmap modules include bx-couchbase, bx-mongodb, and bx-elasticsearch.

Availability & Resources

BoxLang 1.7.0 is available now via:

• BoxLang Quick Installers (Mac, Linux, Windows)
• BoxLang Version Manager (BVM)
• Maven Central
• Direct download: boxlang.io/download

📘 Release Notes: BoxLang 1.7.0
📰 Full Blog Post: BoxLang v1.7.0 Overview
💻 Try Online: try.boxlang.io
📚 Documentation: boxlang.ortusbooks.com

About BoxLang

BoxLang is a next-generation, dynamic JVM language that runs seamlessly across multiple environments—desktop, web, cloud, serverless, and embedded systems. It combines the best features of Java, CFML, Python, Ruby, Go, and PHP to deliver a modern, expressive, and functional syntax with full Java interoperability.

With native capabilities for scheduling, asynchronous execution, event-driven programming, task management, and modular architecture, BoxLang functions as both a language and a framework, serving as a replacement for legacy CFML engines like Adobe ColdFusion and Lucee.

About Ortus Solutions

Ortus Solutions is a leader in modern software development for the JVM ecosystem. The company builds innovative frameworks, tools, and languages, including BoxLang, ColdBox MVC, and CommandBox CLI, which power thousands of applications globally.

🌐 www.ortussolutions.com

Media Contact
Ortus Solutions, Corp.
📧 info@ortussolutions.com
🌍 www.ortussolutions.com
🧩 boxlang.io | github.com/ortus-boxlang/boxlang

The post BoxLang 1.7.0 Delivers Streaming, Distributed Caching, and Enhanced JVM Performance appeared first on foojay.