Products
Built on decades of proven expertise.
Engineered for decades to come.
A Multi-Directional API
The CobolCloud Compiler Suite was not designed as a conventional compiler, but as a true multi-directional API. On one side, it preserves applications by compiling COBOL exactly as written, ensuring compatibility and continuity.
On the other, it opens those same applications to the technologies that matter today — and the ones that will matter tomorrow. With this architecture, a COBOL module can, with minimal adjustment, be exposed as a web service, encapsulated in a container, or orchestrated in Kubernetes or OpenShift — without being rewritten or distorted.
More importantly, this approach ensures that whenever a new technology emerges, CobolCloud can provide another 'exit' toward it, keeping COBOL relevant again and again.
If an application works and its business rules are sound, there is no reason to replace or rewrite it. Instead, CobolCloud extends it — preserving the hidden business logic embedded in COBOL modules, which represents the true know-how and value of the enterprise.
Compile Without Modification
CobolCloud is designed to preserve mission-critical COBOL applications. Programs can be compiled without changes to the source code while maintaining the runtime behaviors on which they rely. This ensures that applications remain recognizable to development teams after migration, avoiding unnecessary disruption and resistance.
Resolve COBOL Dialects
For decades, COBOL dialects have diverged, often with proprietary behaviors that complicate migration. CobolCloud unifies these variations under a single compiler, eliminating incompatibilities and ensuring equal access to modern technologies.
Rely on Over 30 Years of COBOL Expertise and Compiler Leadership.
CobolCloud builds on more than three decades of COBOL modernization and migration experience, culminating in nearly two decades of continuous compiler innovation — from the COBOL-IT fork of OpenCOBOL in 2008 to the foundation of CobolCloud in 2022. This long-standing expertise, combining field experience and advanced compiler engineering, makes CobolCloud a proven and reliable foundation for enterprise systems.
Flags and
Compatibility
Controls
CobolCloud supports over 200 compiler flags and runtime environment variables, allowing fine-grained control of dialect behaviors. More than 100 refinements ensure deep compatibility with Micro Focus, while significant adjustments also cover the main IBM dialects, BS2000, RMCOBOL, and others. This breadth of compatibility ensures COBOL applications can be preserved and migrated with confidence.
Transpiler Architecture
The CobolCloud compiler is a transpiler: COBOL code is translated into C, then compiled into optimized executables using the host C compiler.
This process is fully transparent to developers, who continue working in COBOL while benefiting from the performance and portability of modern C compilers.
By delegating binary generation to the host C compiler, CobolCloud leverages decades of vendor optimization. The result is a compact, coherent, and high-performance solution that naturally aligns with operating systems and modern toolchains. This architecture also accelerates evolution: syntax refinements and new features can be delivered quickly, reducing migration times, accelerating time to market, and improving return on investment.
Built for Modern Environments
The Cloud is now the natural target for most enterprise modernization strategies. CobolCloud ensures COBOL applications integrate smoothly into this world:
- Applications can be containerized and orchestrated with Kubernetes.
- CI/CD pipelines can include COBOL modules alongside other languages.
- Runtime information can be exposed to modern monitoring and logging frameworks.
Advanced Features
Beyond the standard capabilities of a modern COBOL compiler — including full support for the EBCDIC character set — the CobolCloud Compiler Suite provides advanced tools for reliability and optimization:
- Advanced debugging with process attach and mixed COBOL/C/Java source navigation.
- Profiling and Code Coverage to analyze execution paths and improve performance.
- Checkpoint/Reload to save and restore runtime sessions.
- Automated runtime dump capture for faster problem resolution.
- Integration hooks to connect runtime behavior with external monitoring systems.
These features give teams greater visibility and control, reducing downtime and ensuring smoother evolution of mission-critical systems.
Conclusion
The CobolCloud Compiler Suite is a proven, enterprise-grade toolchain that combines backward compatibility with forward integration. Its modular design and nearly two decades of migration expertise make it a solid foundation for running, preserving, and evolving COBOL applications in today’s and tomorrow’s environments.
Explore further
Talk to a CobolCloud expert and tell your story.
Together, we’ll explore your foundations, your current challenges, and your ambitions for tomorrow.
Integrating the CobolCloud multi-directional API with Microsoft VS Code
The CobolCloud Workbench is integrated with Microsoft VS Code, which has rapidly emerged as the cross-platform, open source development environment of choice.
For more information on VS Code, please visit: https://code.visualstudio.com/docs
The VS Code environment is powerful and highly extensible, but what really sets it apart is the vast ecosystem of open source extensions that surrounds it. With a constantly expanding catalog, developers can build a workbench that perfectly fits their workflow. CobolCloud adds to this ecosystem with its own extension, seamlessly integrated into the VS Code experience.
Productivity for COBOL Development
The CobolCloud Workbench increases programmer productivity by providing an intuitive way to use the extensive configuration capabilities of the CobolCloud Compiler. It offers developers guidance and efficiency by:
- Simplifying the use of CobolCloud’s multi-directional API.
- Supporting the highly configurable compiler and runtime systems designed to accommodate a wide range of dialects and proprietary syntax.
- Providing a powerful COBOL debugger that integrates into complex enterprise stacks.
- Enabling advanced development utilities such as Profiling and Code Coverage.
Available on Linux and Windows, the CobolCloud Workbench allows mission-critical COBOL applications to run in the most widely used operating environments, both on-premises and in the Cloud.
Extensible and Cloud-Ready
The CobolCloud Workbench is not limited to COBOL — it integrates naturally into hybrid development environments. Within VS Code, developers can mix COBOL with C, Java, Python, or other languages, while using a single unified IDE for editing, debugging, and testing.
Explore further
Talk to a CobolCloud expert and tell your story.
Together, we’ll explore your foundations, your current challenges, and your ambitions for tomorrow.
COBOL applications compiled with CobolCloud can be:
- Exposed as web services.
- Packaged into containers and orchestrated with Kubernetes or OpenShift.
- Integrated into CI/CD pipelines for continuous delivery and DevOps practices.
This ensures COBOL remains a stable, central component of enterprise IT, while aligning with modern development and deployment standards.
The CobolCloud Extension
The CobolCloud Extension provides the means of configuring and executing Compile, Run, and Debug operations, and adds valuable COBOL-specific enhancements to the VS Code editor.
Configuration Extensions
Workbench Settings
Allow configuration of compile, run, and debug operations. Includes designating the setup file, setting compiler flags, designating the compiler configuration file, using a precompiler, or attaching to a database. Enables Profiling and Code Coverage utilities, and provides editor features like colorization, navigation, and customizable shortcuts.
Configure Compiler for use with precompiler
Allow configuration of compile, run, and debug operations. Includes designating the setup file, setting compiler flags, designating the compiler configuration file, using a precompiler, or attaching to a database. Enables Profiling and Code Coverage utilities, and provides editor features like colorization, navigation, and customizable shortcuts.
Configure Runtime for use with database
Compiled objects can be pre-linked with database libraries at compile time. Database calls can be configured as static calls using the configuration file.
Enable Code Coverage
Reports on code used and unused during a runtime session.
Enable Profiling
Reports elapsed time and CPU time spent during runtime execution, either by paragraph/section or for external calls.
Debugger Extensions
Variables View
Displays all variables and their current values across the Working-Storage, File, Linkage, and Screen Sections of the Data Division.
Watch View
In a program with a very large number of Data Division variables, you may wish to disable the Variables View and selectively add only those variables you want to monitor. Variables in the Watch View can also be used to create expressions, such as CUSTOMER-STATUS = 00. An expression will cause the debugger to pause when the condition is met, and the Watch View will be updated.
Call Stack View
Displays the sequence of CALLs made during the runtime session. For each CALL, it shows which program invoked the current one, and where the CALL occurred.
Hex to ASCII Hover
Provides ASCII display of variables declared with Hex notation.
Debug Attach
Allows COBOL programs called from transaction monitors or other programs written in C to be paused and opened directly in the CobolCloud debugger.
Breakpoints View
Lists the program and line number where a breakpoint has been set.
Debug Console
Shows console output while running the debugger.
Debugger Toolbar
Provides quick access to functions like Continue, Step Over, Step Into, Step Out, Restart, and Stop. Integrated with VS Code keybindings for smooth developer workflow.
Debugger Extensions
Assign keybindings to dozens of Code Editor behaviors. Keybindings can be customized, and XEdit-style bindings are supported.
Colorization
Assign distinct colors to keywords, literals, variable names, comments, and integers for better readability.
Code Editor Extensions
Code Editor Keyboard Shortcuts
Assign keybindings to dozens of Code Editor behaviors. Fully customizable.
IntelliSense for keywords
Provides code completion for COBOL keywords and intrinsic functions.
Snippets for keywords, intrinsic functions, and callable routines
Templates accelerate the creation of complex structures such as File I/O verbs, Evaluate/If statements, intrinsic functions, and callable libraries.
Peek at copybooks
Hover over copyfiles to see contents and definitions.
Remove comments
Enables comments in source code to be removed automatically.
Align storage items
Apply consistent coding standards for improved readability of storage items.
CLDSQL has two basic modules
An intelligent preprocessor that converts the original COBOL ESQL code, analyzes it, and generates code to be used by the CobolCloud compiler. In the pre-processing phase, there is an analysisphase and a translation phase, each of which can be adapted to exploit the capabilities of the database in use most efficiently.
A series of runtime libraries and tools that interface with the DBMS used by the client. The CLDSQL runtime component allows it to support the most widely used open-source and proprietary database solutions, while also being easily extensible to newly emerging database solutions.
Both modules are highly modular multi-directional APIs
CLDSQL is modular both during the preparation phase (parsing and generation of ESQL statements) and at runtime. The translator module in CLDSQL can apply transformation rules to rewrite statements (loops, cursor usage, etc.) with the aim of keeping performance intact when migrating from the mainframe environment to open systems.
The preprocessor in CLDSQL can point out features and potential problem areas in the code that might need particular attention when porting an application from the mainframe to open systems. CLDSQL can handle natively a plurality of databases at runtime, also simultaneously. Due to its modular nature, database support can be easily augmented or even replaced with custom-tailored modules, to better accommodate features used by the client’s application.
CLDSQL allows you to control its behaviors
CLDSQL provides a wide-ranging set of parameters that can be used to control its behavior during both the generation and the runtime phase. You can decide how character fields should be treated, for instance, or how SQL statement parameters should be generated. You can specify all the connection options supported by the DBMS of your choice. Decide to use the native cursor library provided by your DBMS or the emulated one in CLDSQL. There are also options to control the COBOL syntax that will be used, or how the runtime libraries should be called.
Or you can simply use the defaults implemented in CLDSQL if they suit your process. You can choose to take control, or not!
The CLDSQL transformation engine reduces the need to change your code
Migrating from a mainframe environment to open systems does not just mean bringing it over or making it run. Radically different architectures also imply completely different assumptions about CPU and I/O speed, memory layout, etc. Subtle differences in how an SQL statement is interpreted and executed by each DBMS, can slow a perfectly-written program down to a crawl, or make it consume a huge quantity of resources. By using a CLDSQL transformation rule, it becomes possible to selectively target particular statements or situations within a program and adjust the software’s behavior to meet specific requirements. All avoiding the need for direct code modifications and minimizing the risk of regressions or undesired changes in functionality.
The transformation engine integrated in CLDSQL exposes SQL statements, cursors and variable definitions in your code as objects that can be manipulated with the included interpreter. You do not need to modify the COBOL SQL code directly; reusable rules or tasks can be directly applied to your programs during the preparation phase without modifying the original COBOL SQL code. Queries can be manipulated and enriched: you can do things like add or remove columns, modify the function names used by a statement to make them compatible with your DBMS of choice, and much more!
Every software has its own needs in terms of performance, portability, and customization: CLDSQL comes with a predefined set of transformation rules, but new ones can be written to support a given migration project or even for a specific program. Since you do not need to modify your original code, you can easily test the best strategy for your ESQL:
- Run your original code promptly and easily, then fine-tune your application for maximum performance.
- Or incorporate custom-made rules and tasks into your workflow to get maximum performance and reliability from the start.
Integration
CLDSQL can use information generated by other tools of the CobolCloud suite (Profiler and Compiler) to analyze the code and generate the best possible data access strategy for each scenario. The preparation components of CLDSQL (parser and transformation libraries) can output a wealth of information about the programs that goes well beyond a standard COBOL listing, ready to be automatically processed by other tools (other preprocessors, debuggers, profilers, etc.) or used to integrate COBOL programs with other business processes.
Extensible logging system
CLDSQL uses an advanced logging system that can be tailored and extended to support multiple logging targets and filters. When needed — whether for debugging purposes, or simply to keep tabs on the application — custom logging modules can be written and added to the CLDSQL runtime logging system.
Cross-platform
CLDSQL is natively available on Windows and Linux. Conformance tests are executed separately — before each release — in each environment to ensure a consistent and flawless experience.
Make your COBOL applications shine in the Cloud
Thanks to its extensible and pluggable architecture, CLDSQL enables applications to easily connect with databases residing in a shared or private cloud environment. Its low disk and memory footprint, together with low overhead and fast startup and connection time, make it ideal for containerized applications. CLDSQL supports the major databases on standard cloud architectures, including enhanced connection and service modes.
Explore further
Talk to a CobolCloud expert and tell your story.
Together, we’ll explore your foundations, your current challenges, and your ambitions for tomorrow.