ContentBox RSS Feed https://www.ortussolutions.com Ortus Solutions, Corp (www.ortussolutions.com) http://www.rssboard.org/rss-specification FeedGenerator Wed, 21 Oct 2026 13:33:32 GMT Wed, 21 Oct 2026 13:33:32 GMT Keeping Adobe ColdFusion updated is an important part of maintaining a secure and reliable application environment. But applying a ColdFusion update is not always as simple as installing the latest patch and restarting the server. Updates can include security fixes, library upgrades, JVM-related changes, changes to the ColdFusion Administrator, updated packages, bug fixes, and changes in runtime behavior. Most updates will not cause problems for most applications. But when you're responsible for a large or long-running ColdFusion application, even a small behavioral change can have unexpected consequences. That's why a ColdFusion update should be treated as a deployment — not just server maintenance. A Successful Update Can Still Affect Your Application There's an important distinction between an update installing successfully and your application continuing to behave exactly as expected afterward. A ColdFusion server can start normally. The Administrator can load. Your application can respond to requests. And something can still be wrong. A change in regular expression behavior, Java integration, component handling, security defaults, permissions, libraries, or another part of the runtime may only become visible when a particular section of your application executes. This becomes especially important with older applications. A ColdFusion application that has been running for 10 or 15 years may contain thousands of templates, components, integrations, scheduled tasks, Java dependencies, and assumptions about runtime behavior accumulated across multiple versions of ColdFusion. Nobody remembers all of them. The update is therefore only one part of the job. The other part is determining whether your application is ready for it. Security Updates Create an Important Trade-Off This becomes particularly uncomfortable when an update contains security fixes. You don't want to postpone an important security update. But you also don't want to install an update directly into production without knowing whether it changes application behavior. And if testing reveals a compatibility problem, you can suddenly find yourself in a difficult position: Do you deploy the security update and risk breaking the application, or delay the update while you investigate the problem? Neither is a particularly attractive option. The best way to avoid that situation is to discover compatibility problems before the production deployment. Before Updating ColdFusion, Know What You're Running Before installing an update, create a basic inventory of the environment. At minimum, you should know: Your ColdFusion version and current update level The Java/JVM version being used Your application server configuration Installed ColdFusion packages Third-party Java libraries and JARs Database drivers External APIs and integrations Scheduled tasks Custom JVM arguments Security-related configuration Any native or OS-level dependencies Whether the application uses older or less common CFML functionality This sounds basic, but we regularly encounter long-running applications where nobody has a complete picture of the production environment anymore. That makes every upgrade more dangerous than it needs to be. Read More Than the Security Headline If an update addresses a security vulnerability, it's tempting to focus exclusively on the security bulletin. Don't. Review the complete release notes and technical documentation. Look for changes involving areas your application depends on, including: CFML behavior. Has anything changed in functions, components, scopes, queries, regular expressions, serialization, or other language behavior? Java and JVM changes. Does the update require or recommend a different Java version? Does your application use Java libraries directly? Security defaults. Have defaults, permissions, authentication mechanisms, or protections changed? ColdFusion Administrator. Are there changes to configuration, permissions, packages, or administrative functionality? Bundled libraries. Have underlying Java libraries or other dependencies been upgraded? Bug fixes. This one is easy to overlook. A bug fix can sometimes change behavior that an application has unknowingly depended on for years. The question isn't simply: "What did Adobe fix?" It is also: "Does anything Adobe changed intersect with something our application depends on?" Never Let Production Be Your Test Environment For business-critical ColdFusion applications, updates should first be deployed into an environment that resembles production as closely as practical. That means more than checking whether the home page loads. Exercise the application. Test authentication. Run important business workflows. Test scheduled tasks. Verify database connectivity. Exercise external integrations. Check file operations. Test email. Review application and server logs. Validate Java integrations. Run automated tests if you have them. And pay particular attention to functionality that depends heavily on the ColdFusion runtime itself. The more important the application, the less appropriate a simple smoke test becomes. Automated Tests Become Extremely Valuable Here One of the best protections against update-related regressions is a good automated test suite. Unfortunately, many legacy ColdFusion applications don't have one. That doesn't mean you need to stop everything and spend six months writing tests before installing an update. Start with the workflows that matter most. Identify the functionality that would create a serious business problem if it stopped working and build tests around those areas first. Over time, that test suite becomes more than a development tool. It becomes part of your upgrade strategy. When a new ColdFusion update arrives, you can deploy it to staging, run the suite, and get a much faster indication of whether something fundamental has changed. For CFML applications, tools such as TestBox can make this process much easier to introduce incrementally. Have a Rollback Plan Before You Need One The worst time to decide how to roll back an update is after production has stopped working. Before deploying, determine: How you will restore the previous ColdFusion state Whether configuration changes also need to be reversed Whether packages or libraries changed Whether database or application changes accompany the deployment How long rollback will take Who has authority to make the rollback decision Then document it. A rollback plan doesn't mean you expect the update to fail. It means you've planned for the possibility that it could. Monitor the Application After the Update Passing your test suite doesn't mean the job is finished. Some problems only appear under real production traffic or in workflows that run infrequently. After deploying an update, pay closer attention than usual to: ColdFusion logs Application errors JVM behavior Memory usage Database connection pools Response times Scheduled tasks External integrations User-reported issues Establish a baseline before the update whenever possible. It becomes much easier to identify abnormal behavior when you know what normal looked like beforehand. Older ColdFusion Applications Require Extra Care The further an application is from its original development environment, the more important this process becomes. An application originally built for an older ColdFusion release may have survived years of incremental upgrades. That doesn't necessarily mean it is ready for the next one. It may depend on deprecated functionality, old Java libraries, undocumented configuration, legacy integrations, or runtime behavior that nobody on the current team knows about. And sometimes the developers who originally built the application are no longer there. At that point, what appears to be a ColdFusion update can become a modernization project. That's not necessarily a bad thing. It's often an opportunity to identify technical debt, improve testing, document the environment, update dependencies, strengthen security, and reduce the risk associated with future upgrades. What If You Discover a Problem? Finding a compatibility problem during testing is inconvenient. Finding it in production is much worse. If an update causes unexpected behavior, resist the temptation to immediately start changing application code everywhere. First determine where the change is coming from. Is it ColdFusion itself? A JVM change? A bundled library? A package? A security setting? An application server configuration? A third-party dependency? Or application code that was relying on undocumented or unintended behavior? Once you understand the cause, you can decide whether the right response is a configuration change, application fix, temporary workaround, rollback, or escalation to Adobe. That investigation is often where experienced ColdFusion support becomes valuable. Treat ColdFusion Updates as Part of Your Modernization Strategy If every ColdFusion update creates uncertainty, that's telling you something about the application. The long-term solution isn't to stop updating. It's to make updating less dangerous. That may mean introducing automated testing, documenting your infrastructure, upgrading Java dependencies, removing deprecated functionality, improving observability, containerizing environments, or gradually modernizing parts of the application. But there is another question worth asking: If you're already investing time and resources to keep a legacy CFML application compatible with a changing runtime, is continuing on the same runtime automatically the best long-term choice? For many years, ColdFusion teams had relatively few practical alternatives. That's no longer the case. Your CFML Application May Have More Options Than You Think BoxLang provides a modern JVM-based runtime capable of executing existing CFML applications through its CFML compatibility layer. That distinction matters. Evaluating BoxLang doesn't necessarily mean rewriting your application, converting all your CFML code, or committing to a migration. You can start by testing. Run the existing application in a controlled BoxLang environment. Exercise the same workflows you would test during a ColdFusion upgrade. Identify compatibility issues. Review dependencies. Measure performance. Determine what would need to change — and, just as importantly, what wouldn't. In fact, much of the work you're already doing to prepare for a safe ColdFusion upgrade can help answer the BoxLang question as well: What CFML functionality does the application depend on? What Java libraries does it use? What external integrations are involved? What scheduled processes need to work? What database drivers and connections are required? What functionality needs automated testing? What assumptions has the application accumulated over the years? You don't have to speculate about whether another runtime could support your application. You can test it. The result may be that staying on Adobe ColdFusion is still the right decision for your organization. Or you may discover that moving to BoxLang is considerably more achievable than you expected. Either way, you now have something valuable that you didn't have before: a choice. And having a tested alternative can fundamentally change the way you think about the next ColdFusion upgrade, licensing decision, or modernization project. Planning a ColdFusion Update? If you're running a business-critical ColdFusion application and aren't sure what will happen when you apply the next update, you don't have to find out in production. Ortus Solutions can help assess your ColdFusion environment, identify upgrade risks, test application compatibility, troubleshoot update-related issues, and build a safer path toward a supported and maintainable platform. And if you're already investing in that assessment, it may be the perfect opportunity to answer another question: Could this application run on BoxLang? We can evaluate both paths — upgrading your existing Adobe ColdFusion environment and testing your application on BoxLang — so that your next technology decision is based on evidence rather than assumptions. You don't have to decide to migrate to BoxLang to find out whether you could. Planning a ColdFusion upgrade or curious how close your application already is to running on BoxLang? Talk to the Ortus Solutions team. https://www.ortussolutions.com/blog/updating-adobe-coldfusion-isnt-always-just-installing-the-latest-patch Wed, 21 Oct 2026 12:30:00 GMT cristobal@ortussolutions.com (Cristobal Escobar) https://www.ortussolutions.com/blog/updating-adobe-coldfusion-isnt-always-just-installing-the-latest-patch Ortus Solutions today announces BoxLang AI 3.6, the release that connects the AI framework to the rest of the BoxLang productivity platform. Your agents can now drive a real browser via bx-playwright, speak and master audio via bx-audio, stream text-to-speech token by token, talk to any MCP server over stdio — and do all of it with the same fluent BoxLang syntax they always have. https://www.ortussolutions.com/blog/boxlang-ai-36-your-agent-now-has-eyes-ears-and-a-voice Tue, 20 Oct 2026 09:06:00 GMT lmajano@ortussolutions.com (Luis Majano) BoxLang Community Into The Box News Releases https://www.ortussolutions.com/blog/boxlang-ai-36-your-agent-now-has-eyes-ears-and-a-voice Ortus Solutions today announces the general availability of BxAudio 1.0, the audio module for BoxLang. Synthesize instruments and drums, arrange them on a beat grid, master to a loudness target, speak text with open license voices, score a video and play sound in a game. All of it from BoxLang, on the JVM. No Python. Nothing native to install. https://www.ortussolutions.com/blog/bxaudio-10-make-mix-master-and-speak-audio-from-boxlang Tue, 20 Oct 2026 09:05:00 GMT lmajano@ortussolutions.com (Luis Majano) https://www.ortussolutions.com/blog/bxaudio-10-make-mix-master-and-speak-audio-from-boxlang Your application is slow. Something is failing. Where do you start looking? On October 28, 2026, at 11:00 AM CDT, join Luis Majano, Ortus Solutions CEO and BoxLang creator, for a live, hands-on look at how observability and AI come together in BoxLang. BoxLang Under the Lens: Observability Meets AI introduces BxLens, Lensy, and the additional monitoring capabilities of BoxLang+. See how to investigate application behavior, understand diagnostic information, and move toward proactive application intelligence. Register on Eventbrite Stop Guessing. Start Seeing. Meet BxLens, the new observability and diagnostics module for BoxLang. BxLens brings request tracing, SQL queries, HTTP calls, errors, JVM metrics, and server health into one debugging bar and operations console. During the session, Luis will explore how BxLens helps you identify bottlenecks, troubleshoot production issues, and understand what your application is doing in real time. If you’ve ever wondered what’s happening beneath a slow request or an application error, this is your opportunity to see BoxLang diagnostics in action. Get AI Insights. Stay in Control. Next, meet Lensy, your AI-powered operations assistant. Lensy analyzes diagnostics, explains problems in plain language, and recommends actions. You remain in control through explicit approvals. Luis will introduce Lensy and demonstrate how it brings AI-assisted analysis into the troubleshooting process. See the Bigger Picture with BoxLang+ The session will also demonstrate how BoxLang+ extends observability with: Multi-server monitoring Intelligent alerts Scheduled reports AI observability for agents, models, tokens, and costs Explore how these capabilities support the move from reactive debugging to proactive application intelligence, all without deploying additional monitoring agents. Join Luis for the Live Demo Get a hands-on introduction to BxLens, Lensy, and BoxLang+, with live demonstrations led by the creator of BoxLang. Webinar: BoxLang Under the Lens: Observability Meets AI Date: October 28, 2026 Time: 11:00 AM CDT Speaker: Luis Majano, Ortus Solutions CEO and BoxLang creator See what’s happening under the hood. Register on Eventbrite. Register Stay Connected with the BoxLang Ecosystem September brought exciting advancements in BoxLang, from new language capabilities and AI-powered development to modernization resources and community initiatives. And there's much more to come! Whether you're exploring BoxLang for the first time or already building with it, there's a growing ecosystem of tools, resources, and developers ready to help you take the next step. Subscribe to Our Newsletter Get the latest BoxLang releases, tutorials, AI innovations, community stories, upcoming events, and exclusive content delivered straight to your inbox. Subscribe Join the BoxLang Community Connect with developers around the world, ask questions, exchange ideas, and contribute to the growing BoxLang ecosystem. BoxTeam Slack — Connect directly with the BoxLang team and fellow developers. Community Forum — Ask questions, share knowledge, and explore community discussions. Start Exploring BoxLang Ready to dive deeper? Explore our official resources, documentation, and development tools: BoxLang — Discover the language, its capabilities, and the latest updates. BoxLang AI — Explore AI-powered development, agents, and integrations. Documentation — Access guides, references, and technical documentation. Try BoxLang — Experiment with BoxLang directly in your browser. GitHub — Explore the source code, contribute, and follow ongoing development. BoxLang Around the World. Building the Next Generation of Developers. https://www.ortussolutions.com/blog/boxlang-under-the-lens-observability-meets-ai-free-webinar Mon, 19 Oct 2026 19:59:00 GMT vcampos@ortussolutions.com (Victor Campos) https://www.ortussolutions.com/blog/boxlang-under-the-lens-observability-meets-ai-free-webinar The bx-image module can now generate and read QR codes. Two new functions, a string member function, and two new bx:image actions. No extra dependencies for you to manage. https://www.ortussolutions.com/blog/qr-codes-come-to-boxlang-images Wed, 14 Oct 2026 13:06:00 GMT lmajano@ortussolutions.com (Luis Majano) BoxLang CacheBox ColdBox MVC CommandBox ContentBox CMS LogBox WireBox https://www.ortussolutions.com/blog/qr-codes-come-to-boxlang-images Ortus Solutions today announces CBSecurity 3.9, a major step forward for securing ColdBox applications. This release adds 12 ready-made security middleware that you attach directly to routes and route groups, with no firewall rules required. https://www.ortussolutions.com/blog/cbsecurity-39-12-security-middleware-for-coldbox-declared-right-on-the-route Tue, 13 Oct 2026 18:55:00 GMT lmajano@ortussolutions.com (Luis Majano) BoxLang CacheBox ColdBox MVC CommandBox ContentBox CMS LogBox WireBox https://www.ortussolutions.com/blog/cbsecurity-39-12-security-middleware-for-coldbox-declared-right-on-the-route Adobe ColdFusion 2021 reaches the end of extended support on November 10, 2026. If your application still runs on this release, the time to decide what comes next is now. Adobe ended core support for ColdFusion 2021 on November 10, 2025. The current extended support period is best effort and does not include security patches or hotfixes. When it ends on November 10 2026, organizations will no longer have that support option from Adobe for ColdFusion 2021. What does the end of extended support mean? The date does not mean that your application will suddenly stop working. Your ColdFusion server may continue running as it does today. The change is that you can no longer count on Adobe’s extended support for that release if you encounter a problem. In practical terms, that can affect your ability to: Get help from Adobe diagnosing a ColdFusion 2021 issue. Receive a hotfix if a product defect affects your application. Get a security update for a newly discovered vulnerability in that release. Rely on Adobe to help resolve issues that arise as your operating system, Java version, database, or other infrastructure changes. ColdFusion 2021 already passed the end of core support in 2025. Adobe identifies Update 23 as the final update for the release. The end of extended support therefore marks the end of the additional, best-effort assistance period; it does not mark the first day without security patches. This does not mean every application will fail or that a security incident is inevitable. It means your organization will have fewer options for vendor assistance if something goes wrong, and will need to manage the technical and security risks itself. That may involve additional monitoring, compensating security controls, in-house troubleshooting, or moving to a supported platform. Older ColdFusion versions may already be outside support If your application runs on a ColdFusion version older than 2021 and you have not taken action, check its lifecycle now. You may already be operating outside the version’s support period, without a current upgrade or migration plan. Running unsupported software does not automatically mean your application has been compromised. It does mean that you may not receive fixes for newly discovered problems, and that your team could have to investigate or mitigate issues without help from the vendor. That creates risk for security, uptime, maintenance, and future modernization work. Your application will keep running. The risk does not go away. The impact depends on your system. A stable application with strong internal expertise and security controls may be manageable in the short term. A business-critical application with limited documentation, aging infrastructure, or few people who understand the code may need more urgent attention. A migration or upgrade also takes planning. Teams may need to review custom code, third-party libraries, Java versions, integrations, infrastructure, and testing coverage. Starting that work only when support ends can leave too little time to evaluate options and test changes. Choose a path that fits your application There is no single right answer for every ColdFusion system. Depending on your application, team, and timeline, you might: Stabilize and maintain the application while planning a longer-term modernization. Evaluate BoxLang as an alternative runtime for CFML applications. Modernize selected parts of the system incrementally. BoxLang supports CFML through its compatibility capabilities, which can make it a migration option for some applications. Compatibility depends on the application’s code, frameworks, libraries, and integrations, so a technical assessment should come before any migration decision. Start with an assessment Ortus Solutions helps teams troubleshoot and support ColdFusion applications, assess modernization options, and plan migrations. We can review your current version, application dependencies, infrastructure, and business constraints, then help you identify a practical next step. If you are running ColdFusion 2021, or an earlier release, do not wait for the deadline to start planning. Schedule a free 30-minute assessment with Ortus Solutions. Sources: Adobe ColdFusion 2021 support timeline · ColdFusion 2021 updates https://www.ortussolutions.com/blog/acf2021-extended-support-ends-on-november-10-is-your-application-ready Tue, 13 Oct 2026 15:27:00 GMT cristobal@ortussolutions.com (Cristobal Escobar) https://www.ortussolutions.com/blog/acf2021-extended-support-ends-on-november-10-is-your-application-ready Ortus Solutions today announces the general availability of TestBox 7.2, the biggest TestBox release in years. Built on the new bx-playwright 1.0 module, BoxLang specs can now drive a real browser, assert with web-first matchers that wait until they pass, and keep the screenshots, traces and videos of every failure. Around it, TestBox gains spec retries, a Run Failed option, a rebuilt set of HTML reporters with Ask AI on every failure, and a new Agent reporter that lets AI agents read a test run at minimal token cost. https://www.ortussolutions.com/blog/testbox-72-real-browser-testing-smarter-reports-and-agent-ready-results Tue, 13 Oct 2026 15:00:00 GMT lmajano@ortussolutions.com (Luis Majano) BoxLang IDE OpenSource Releases TestBox https://www.ortussolutions.com/blog/testbox-72-real-browser-testing-smarter-reports-and-agent-ready-results Ortus Solutions today announces the general availability of bx-playwright 1.0, fluent browser automation and testing for BoxLang, powered by Microsoft Playwright. It ships alongside TestBox 7.2 and ColdBox 8.3, which bring real-browser testing straight into your specs. Drive Chromium, Firefox and WebKit, test full user journeys, render PDFs and images, and give your AI agents a real browser to verify the BoxLang applications they build. https://www.ortussolutions.com/blog/bxplaywright-10-real-browsers-fluent-boxlang-built-for-ai-agents Tue, 13 Oct 2026 15:00:00 GMT lmajano@ortussolutions.com (Luis Majano) BoxLang CacheBox ColdBox MVC CommandBox ContentBox CMS LogBox WireBox https://www.ortussolutions.com/blog/bxplaywright-10-real-browsers-fluent-boxlang-built-for-ai-agents Ortus Solutions today announces the general availability of ColdBox 8.3, a feature release focused on real-browser testing and route composition. Annotate a BaseTestCase spec with @browser and drive a real browser against your running ColdBox application, with named route helpers that know your routes. And with the Playwright driver behind it, the same browser can render PDFs and screenshots of your ColdBox views. This release also brings named route middleware with registerMiddleware(), route metadata shared by a whole group(), integration tests that run route middleware like a real request, and thread-safe WireBox scope wiring. https://www.ortussolutions.com/blog/coldbox-830-test-and-render-your-app-with-a-real-browser Tue, 13 Oct 2026 15:00:00 GMT lmajano@ortussolutions.com (Luis Majano) BoxLang CacheBox ColdBox MVC CommandBox ContentBox CMS LogBox WireBox https://www.ortussolutions.com/blog/coldbox-830-test-and-render-your-app-with-a-real-browser Sentry 2.2.0 Released! Sentry 2.2.0 brings tracing, structured logs, metrics, browser feedback, and a handful of welcome fixes to your CFML and BoxLang applications. There’s quite a bit packed into this minor release! And yes, it is a minor release. Your existing error reporting continues to work, and all of the new integrations are opt-in. You can upgrade for the bug fixes without turning on anything else. Let’s get to the changes. What’s New? See where the time goes Getting an exception into Sentry is helpful. But sometimes the problem is a request that takes five seconds and doesn’t throw an exception at all. Which query was slow? Did we miss the cache? Were we waiting on another service? This release adds tracing for requests, queries, background jobs, CacheBox operations, and outbound HTTP calls. These spans give you a breakdown of the work happening inside a transaction. You can enable request tracing in your ColdBox configuration: moduleSettings.sentry = { DSN: getSystemSetting( "SENTRY_DSN", "" ), environment: "production", release: "my-app@1.0.0", enableRequestTracing: true, tracesSampleRate: 0.1 }; This example samples 10% of requests. Adjust that rate for your application’s traffic and your Sentry usage. You can also wrap your own application code in a span: sentry.withSpan( "load inventory", function( span ) { return loadInventory(); } ); Now that operation has a name and a duration in the trace. Much easier to investigate than “something in this handler is slow.” Query tracing Database queries are often a good place to start when tracking down a slow request. Sentry 2.2.0 adds query instrumentation through runtime listeners and compatible qb hooks, depending on your engine and installed versions. For direct queries, you can use withQuerySpan: result = sentry.withQuerySpan( sql, function( span ) { return queryExecute( sql, parameters, options ); }, "postgresql" ); The wrapper records the query’s duration and status while preserving the callback’s result or exception. SQL literals are scrubbed, and bindings and result data aren’t collected. The automatic integrations have some runtime requirements, so check the documentation before enabling them. The manual wrapper is useful wherever you need explicit coverage. Background jobs, caches, and external calls The work doesn’t always end when the request does. Queue tracing can connect a job back to the request that scheduled it, with separate measurements for waiting and processing. Cache instrumentation records hits and misses without collecting the cached values. HTTP wrappers let you measure calls to other services and propagate trace headers to configured destinations. These integrations help answer some very practical questions: are jobs spending their time waiting or working? Is the cache helping? Is our application slow, or is the service it calls slow? Structured logs, metrics, and check-ins There are also new APIs for structured logs and metrics: captureLog sends structured diagnostic messages. counter, gauge, and distribution record measurements. withMonitor reports check-ins for scheduled work. For example, you can wrap an hourly task like this: sentry.withMonitor( "hourly-work", function() { return performWork(); }, { schedule: { type: "interval", value: 1, unit: "hour" }, checkin_margin: 2, max_runtime: 10 } ); This gives Sentry the schedule and matching check-ins for the work. Logs, metrics, and monitors have separate enablement settings, so you can choose which ones to add. Available monitor features depend on your Sentry plan. Browser Feedback, Screenshots, and Replay A bug report that says “it didn’t work” can leave you with a lot of questions. What page was the user on? What had they entered? What happened just before the problem? The new browser companion adds a feedback widget with screenshots and session replay, along with browser tracing and supported Web Vitals. The release includes built browser assets, so a plain CFML or BoxLang layout can use them without adding a Node build to the application. Bundler-based applications can use the included browser sources instead. The widget supports keyboard and touch interaction, screenshot review and removal, and retries when delivery fails. Your application decides who is eligible to use it, which makes it possible to start with a small group of users. There’s an important detail here: opening the feedback widget uploads the recent replay buffer. The message and screenshot are uploaded when the user submits the report. The widget explains that behavior to the user. Capture uses conservative masking by default. If you want ordinary page content and form values to be readable, that requires an explicit capture policy. Review that policy for your application before enabling it. Bug Fixes There are several fixes for existing error reporting as well: Fixed a race where concurrent exception capture could access the Sentry singleton before initialization finished. Fixed timestamp generation so UTC ISO timestamps and epoch timestamps agree on CFML and native BoxLang. Improved stack-trace handling when a source file can’t be found. Made rewritten index.bxm URLs behave consistently with index.cfm URLs. That last one came from a real report. The module already removed /index.cfm from rewritten request URLs, but it didn’t do the same for /index.bxm. A request for /foo/bar could therefore appear in Sentry as /index.bxm/foo/bar. Now both root front controllers are handled consistently. The release candidate also passed all 13 engine/framework CI combinations, browser tests and builds, and formatting checks. Getting Started Install Sentry 2.2.0 with CommandBox: box install sentry@2.2.0 If you already use the module, your existing configuration can stay in place. Pick an integration that would help you understand your application and start there. There’s no need to turn everything on at once. You can find configuration examples and integration requirements in the observability guide. As always, issues and pull requests are welcome. I’d love to hear what you’re using it for! https://www.ortussolutions.com/blog/sentry-220-released Thu, 08 Oct 2026 19:59:00 GMT vcampos@ortussolutions.com (Victor Campos) https://www.ortussolutions.com/blog/sentry-220-released Ortus Solutions today announces the official release of the BoxLang package for Sublime Text 4, the newest member of the BoxLang productivity tool suite. https://www.ortussolutions.com/blog/boxlang-for-sublime-text-released Thu, 08 Oct 2026 14:20:00 GMT lmajano@ortussolutions.com (Luis Majano) BoxLang Community Into The Box News Releases https://www.ortussolutions.com/blog/boxlang-for-sublime-text-released Ortus Solutions today announces the general availability of RuleBox 2.0.0, a modern, natural-language rules engine for BoxLang and ColdBox applications. It is a BoxLang-only rewrite, and it ships with rules as data, declared rulebooks, dry runs, an audit trail, and a built-in Rule Visualizer. https://www.ortussolutions.com/blog/rulebox-20-a-natural-language-rules-engine-for-boxlang-and-coldbox Wed, 07 Oct 2026 11:01:00 GMT lmajano@ortussolutions.com (Luis Majano) BoxLang CacheBox ColdBox MVC CommandBox ContentBox CMS LogBox WireBox https://www.ortussolutions.com/blog/rulebox-20-a-natural-language-rules-engine-for-boxlang-and-coldbox Your CFML application may be old, large, and business critical. That doesn't mean modernization has to start with a rewrite. When organizations talk about modernizing a legacy ColdFusion application, the conversation can quickly become much bigger than it needs to be. Do we need a new frontend? Should we rebuild the APIs? Do we need React or Vue? Should we replace the application entirely? How many developers will that require? How long will it take? And perhaps the most important question: what could we break along the way? For many organizations, the application they're discussing isn't some abandoned piece of software. It's a production system with years of accumulated business logic, integrations, workflows, and knowledge embedded in it. Michael Rigsby described this reality very well during his Into the Box 2026 session, From Legacy to Modern, CBWIRE Gets You There Faster and Projects Finished Under the Wire. Most development teams, he pointed out, don't get a brand new greenfield project every quarter. They have existing applications, tight deadlines, small teams, stakeholders asking for more modern experiences, and sometimes hundreds of thousands of lines of CFML that have been running successfully for years. That's the environment in which modernization actually happens. And it leads to an important idea: Modernization doesn't have to mean starting over. Start With the Problem, Not the Rewrite Imagine a ColdFusion application with a traditional customer search. The user enters a term, submits the form, the server processes the request, and the entire page reloads with the results. It works. Maybe it has worked for fifteen years. But users now expect something smoother and more responsive. The obvious temptation is to start thinking about rebuilding the frontend using a modern JavaScript framework. That may be appropriate in some situations. But what if the existing business logic is perfectly good? What if the application already has the services, validation, security, and database interactions you need? Why replace all of that simply to improve the user experience? This is where Rigsby's demonstration with CBWIRE becomes interesting from a modernization perspective. He took an existing ColdBox application and converted its traditional customer search into a reactive experience. Instead of rebuilding the application, he reused the existing architecture and business logic. In fact, Rigsby estimated that about 95% of the code in the new CBWIRE component was reused from the existing view. That's a very different definition of modernization. Use a Surgical Tool, Not a Sledgehammer One of the best lines from Rigsby's presentation was his description of CBWIRE as: "the surgical tool, not the sledgehammer." That's also a useful way to think about legacy modernization in general. You don't necessarily need to modernize an entire application at once. You can modernize it component by component. A traditional form can become reactive. A search can stop requiring full page reloads. A dashboard can update automatically. Sorting, filtering, pagination, inline validation, loading indicators, and other modern interactions can be introduced where users will actually notice the difference. Meanwhile, the rest of the application can continue doing exactly what it was doing before. That changes the economics and risk of modernization considerably. Start Where Users Are Feeling the Pain Rigsby offered another piece of advice that we strongly agree with: Start with your most painful forms, the ones users complain about. This sounds simple, but it's an important shift in thinking. Legacy modernization projects often begin with technology: "We need to replace X." "We need to migrate to Y." "We need to rewrite this application." A better starting point is often: Where is the existing application creating the most friction for users or the business? Then find a change that creates visible value without introducing unnecessary risk. Rigsby's recommendation is to choose high impact, low risk targets rather than trying to convert everything at once. That first success matters. Users see an improvement. Stakeholders see progress. Developers learn how the new approach fits into the existing system. And the organization gets evidence that modernization can deliver value before committing to something much larger. Keep the Business Logic That Already Works This may be the most important lesson. Old doesn't automatically mean bad. A CFML application that has been running in production for fifteen years may contain a tremendous amount of proven business logic. Replacing that logic introduces risk. In Rigsby's examples, CBWIRE could sit alongside existing ColdBox handlers and views while continuing to use the same business logic and validation rules. The interface improved without requiring the organization to throw away everything underneath it. That's exactly the kind of decision we look for when approaching a legacy CFML application. What should we replace? What should we refactor? What should we isolate? And equally important: What should we leave alone because it already works? Good modernization isn't measured by how much code you replace. It's measured by how much business value you create while controlling cost and risk. Think in Steps, Not One Giant Project Rigsby summarized his modernization roadmap with another useful principle: Each step is incremental. Each step delivers value. That's how we prefer to approach legacy CFML modernization at Ortus as well. The first phase might address a handful of painful user workflows. The next might introduce better testing around critical functionality. Another could improve application architecture, deployments, integrations, security, or performance. Over time, parts of the application can be refactored or moved where there is a clear reason to do so. The roadmap is driven by the needs of the application and the business, rather than by an arbitrary requirement to replace everything. Sometimes a larger migration really is necessary. But it should be the result of an assessment, not the assumption you start with. Your Legacy ColdFusion Application May Have More Life in It Than You Think If your organization has a mature ColdFusion or CFML application, don't assume your choices are limited to "leave it alone" or "rewrite it." There's a lot of room between those two extremes. Modernization can mean making the application easier to use. It can mean improving architecture. It can mean adding automated testing so developers can make changes with confidence. It can mean fixing performance or security issues. It can mean improving deployments and CI/CD. It can mean gradually replacing the parts of the application that are genuinely holding the business back while preserving the parts that continue to work well. CBWIRE is one example of how that incremental approach can work at the user interface level. The broader principle applies across the application: Modernize where modernization creates value. Want to See It in Action? Michael Rigsby's full Into the Box 2026 session goes much deeper into this approach and includes practical CBWIRE examples and demonstrations. Watch "From Legacy to Modern, CBWIRE Gets You There Faster and Projects Finished Under the Wire" on CFCasts If you're interested in seeing how an existing CFML application can gain modern, reactive functionality without replacing the application underneath it, the session is well worth watching. Not Sure Where to Start With Your Own Application? That's often the hardest part. Ortus Solutions has been working with ColdFusion and CFML applications for two decades. Our consulting team can review your existing application, identify the areas creating the most cost, risk, or user friction, and help you determine where modernization will actually produce a return. That might mean a phased modernization roadmap, architecture improvements, ColdBox or CBWIRE adoption, testing, CI/CD, performance work, security improvements, an engine migration, or simply fixing a few high impact areas while leaving the rest alone. We can provide the assessment and roadmap, work alongside your existing developers, augment your team with experienced CFML engineers, or take responsibility for specific parts of the implementation. You don't have to rewrite your ColdFusion application to start modernizing it. If you're maintaining a legacy CFML application and wondering what you should modernize, what you should keep, and where to start, let's talk. Contact our CFML consulting team and tell us what you're working with. We'll help you figure out a practical next step. Talk to a CFML Expert https://www.ortussolutions.com/blog/modernizing-legacy-coldfusion-doesnt-have-to-mean-rewriting-it Mon, 05 Oct 2026 12:06:00 GMT cristobal@ortussolutions.com (Cristobal Escobar) https://www.ortussolutions.com/blog/modernizing-legacy-coldfusion-doesnt-have-to-mean-rewriting-it Azure joins the serverless family. Scheduled tasks become cluster-safe. And the whole platform gets documentation and skills built for developers and AI agents working side by side. If you run a technology organization, you are being asked to do three things at once: ship faster, keep the estate you already have running, and make AI part of how your teams work. Most stacks make you choose. BoxLang 1.18 is another step toward not having to. https://www.ortussolutions.com/blog/boxlang-1180-released-every-cloud-every-node-every-agent Fri, 02 Oct 2026 15:36:00 GMT lmajano@ortussolutions.com (Luis Majano) BoxLang Community Into The Box News Releases https://www.ortussolutions.com/blog/boxlang-1180-released-every-cloud-every-node-every-agent