Roadmap: From a Simple JavaScript Debugger to a Broader Debugging Platform

1 More Browsers and Devices

Chrome is the starting point, not the destination. CloudIDEaaS currently communicates with Chrome through the Chrome DevTools Protocol (CDP), but browser debugging should not have to remain tied permanently to a single browser implementation.

Additional Browser Support

The roadmap includes support for additional browsers and browser debugging protocols where practical.

WebView and Embedded Browsers

Browser technology increasingly appears inside desktop, mobile, and embedded applications. Future CloudIDEaaS versions may extend the same debugging workflow to WebView-based and other embedded browser scenarios.

2 More Web Server Options

One convenience of CloudIDEaaS is its ability to start a local web server automatically. That works well for straightforward JavaScript and HTML projects, but not every application belongs in the same hosting model.

Future versions are intended to support additional web servers and launch strategies so developers can retain the F5 workflow while using the server environment appropriate for their application.

• Additional built-in server options
• Externally managed development servers
• Custom server launch commands
• Remote server environments

3 Advanced Debugging Capabilities

The first versions of CloudIDEaaS focus on capabilities developers use constantly: breakpoints, stepping, call stacks, scopes, variables, and expression evaluation.

The roadmap moves progressively deeper into advanced debugging.

Async Call Stacks

Modern JavaScript frequently crosses asynchronous boundaries. Better async stack handling can make it easier to follow execution across promises, callbacks, timers, events, and other asynchronous operations.

Deeper Runtime Inspection

Additional debugger functionality can expose more of the runtime state available through the underlying debugging protocols while keeping those capabilities accessible from the IDE.

4 More launch.json Options

Convention over configuration remains central to CloudIDEaaS, but convention does not mean eliminating configuration entirely. Developers with more complex applications need additional control.

Planned configuration expansion includes:

• Working directory and webRoot configuration
• Additional browser launch options
• Server configuration
• Target configuration
• Advanced debugging behavior

5 A Plugin-Based Debugging Backend

One of the most significant architectural directions on the roadmap is separating the CloudIDEaaS front-end experience from a single debugging backend.

The goal is a plugin-oriented model in which CloudIDEaaS can load or launch different backend CLI processes capable of participating in the debugging architecture.

Visual Studio Code
        |
        | DAP
        v
+-----------------------+
|      CloudIDEaaS      |
|   Debugger Front End  |
+-----------------------+
        |
        +----------+----------+----------+----------+
        |          |          |          |          |
        v          v          v          v          v
   JavaScript   Node.js   TypeScript    Java      Others
     Backend    Backend     Backend    Backend    Plugins

Potential language and runtime targets include:

• Java
• Node.js
• TypeScript
• JavaScript
• Additional languages and runtimes

This architecture could move CloudIDEaaS toward a debugging platform rather than a debugger permanently tied to one runtime.

6 Front-End Framework Integration

JavaScript development increasingly happens through frameworks rather than directly against standalone JavaScript files. The roadmap therefore includes deeper integration with popular application frameworks and their development workflows.

• React
• Angular
• Vue
• Flutter

Framework support may include source-map handling, project detection, launch conventions, development-server integration, generated-code handling, and framework-aware debugging behavior.

7 Container and Cross-Machine Debugging

The code being edited and the code being executed increasingly live in different places.

A developer might run Visual Studio Code on Windows while the application executes inside a container, virtual machine, remote development environment, or another physical computer.

Developer Machine
+----------------------+
|  Visual Studio Code  |
+----------------------+
           |
           | DAP
           v
+----------------------+
|    Debug Adapter     |
+----------------------+
           |
           | Remote Transport
           v
+----------------------+
| Container / VM /     |
| Remote Machine       |
+----------------------+
           |
           v
   Application Runtime

The objective is to preserve a familiar debugging experience even when the actual application or debugger executes somewhere else.

8 Full DAP and CDP Protocol Support

CloudIDEaaS sits between two important debugging protocols. Visual Studio Code communicates with the debugger through the Debug Adapter Protocol (DAP), while the current browser implementation communicates with Chrome through the Chrome DevTools Protocol (CDP).

The roadmap calls for progressively broader implementation of both protocols where their capabilities provide useful development experiences.

Visual Studio Code
        |
        | Debug Adapter Protocol (DAP)
        v
+----------------------------+
| CloudIDEaaS Debug Adapter  |
|          C# / .NET         |
+----------------------------+
        |
        | Chrome DevTools Protocol (CDP)
        v
      Chrome

The objective is broad protocol coverage driven by practical debugging needs, rather than implementing protocol messages merely to check boxes.

9 Pluggable Browser and Runtime Protocols

A broader debugging platform should not require every debugging target to communicate through exactly the same protocol.

CloudIDEaaS will investigate dependency-injected protocol implementations so different debugging transports and runtime protocols can operate behind a common architecture.

Potential targets and environments include:

• Chromium and CDP-compatible browser targets
• Node.js debugging targets
• Firefox debugging
• macOS development environments
• Future browser and runtime protocols

The goal is not to pretend every runtime speaks the same protocol. Instead, CloudIDEaaS can provide abstractions that allow different protocols to participate in a consistent debugging experience.

10 Additional IDE Support

A protocol-based debugger creates an interesting architectural opportunity: the debugging backend does not necessarily have to belong exclusively to Visual Studio Code.

One longer-term goal is to investigate adapters or drivers that connect other development environments to the CloudIDEaaS debugging architecture.

• Visual Studio
• IntelliJ IDEA
• Eclipse
• Other development environments capable of hosting or bridging to DAP

This direction could eventually allow debugging components to be reused across development environments rather than recreating an entire debugger for each IDE.

11 VS Code Utilities Beyond the CDP Debugger Domain

Chrome DevTools Protocol is much larger than JavaScript debugging alone. Its domain-oriented architecture creates opportunities for focused CloudIDEaaS utilities that expose additional browser capabilities directly inside VS Code.

Initial areas of interest include:

• Runtime — JavaScript execution and runtime inspection
• Page — navigation, page lifecycle, screenshots, and page operations
• DOM — document structure inspection and manipulation
• CSS — stylesheet and computed-style inspection

Other CDP domains could eventually support tooling around networking, performance, storage, accessibility, browser automation, tracing, and other areas of web development.

This creates an opportunity for CloudIDEaaS to grow beyond a debugger into a collection of focused developer utilities built on the same browser communication infrastructure.

12 Playwright Support

Browser debugging and browser automation increasingly overlap. Playwright support is therefore another direction on the CloudIDEaaS roadmap.

Connecting automated browser execution with interactive debugging could make it possible to reproduce a scenario automatically and then investigate the resulting application state using familiar debugging tools.

Potential integration could connect test execution, browser automation, breakpoint handling, diagnostics, and interactive debugging into a more unified workflow.

13 AI-Enabled Development

Artificial intelligence is also part of the roadmap, but not merely as a label attached to the product. CloudIDEaaS is exploring how AI-assisted development can accelerate the implementation, testing, and maintenance of debugging capabilities.

AI-Driven DAP and CDP Development

DAP and CDP contain large collections of commands, events, messages, capabilities, and data structures. AI development agents may help identify missing protocol coverage, generate implementation scaffolding, create tests, and accelerate the inclusion of additional protocol capabilities.

Agent-Assisted Development

Tools such as GitHub Copilot and future coding agents may increasingly participate in implementing, testing, documenting, and validating roadmap features.

Prompt-Driven Feature Development

A longer-term experiment is determining how much of the architecture can become sufficiently modular and testable that new protocol capabilities can be described at a higher level and implemented with substantial AI assistance.

14 From Debugger to Debugging Platform

Taken individually, these roadmap items look like a list of features. Together, they point toward something larger.

                 DEVELOPMENT ENVIRONMENTS
       VS Code | Visual Studio | IntelliJ | Eclipse
                         |
                         v
                        DAP
                         |
                         v
              +----------------------+
              |      CloudIDEaaS     |
              |  Debugging Platform  |
              +----------------------+
                         |
            +------------+------------+
            |            |            |
            v            v            v
        Debuggers     Runtimes     Utilities
            |            |            |
            +------------+------------+
                         |
                         v
               Protocol Abstraction
                         |
          +--------------+--------------+
          |              |              |
          v              v              v
         CDP        Other Protocols   Automation
          |                              |
          v                              v
       Browsers                       Playwright

The architectural direction is toward interchangeable front ends, debugging backends, runtime protocols, browser targets, and development utilities.

That is a much larger goal than the original Chrome debugger. But the original principle remains important: additional capability should not automatically mean additional friction for the developer.

The Roadmap Will Evolve

This roadmap describes direction, not a fixed delivery schedule.

Some features may prove more valuable than expected. Some may become easier because underlying platforms evolve. Others may become unnecessary because better approaches emerge.

Priorities will be influenced by:

• Developer feedback
• Real-world debugging scenarios
• Community contributions
• Changes to DAP, CDP, browsers, runtimes, and IDEs
• Technical feasibility
• The ability to preserve CloudIDEaaS simplicity

The roadmap is intentionally a living document.