Theia Adopter Story: Samsung Sokatoa — GPU Profiling and Debugging for Android

Table of Contents

Samsung’s Sokatoa is a GPU profiler and debugging tool for Android, built on Eclipse Theia. It is a compelling example of how Theia’s modular and extensible platform enables building highly specialised, domain-specific tools that go far beyond traditional code editing. In this article, we take a closer look at how Sokatoa leverages the Theia ecosystem.

About Sokatoa

Sokatoa was developed by Samsung’s Austin Research and Development Center (SARC) and Advanced Computing Lab (ACL), in collaboration with Google, EclipseSource and LunarG. It is a GPU software profiler designed to help Android developers diagnose and resolve complex graphics performance issues. Its headline capability is multi-frame GPU profiling, which allows developers to analyse rendering behavior across multiple frames simultaneously, revealing intermittent performance issues that are difficult to detect with traditional single-frame capture tools. Other key features include shader editing with on-device replay, rich data visualisations, side-by-side trace comparison, and pipeline debugging views. Sokatoa supports Samsung’s Xclipse GPU as well as GPUs from Qualcomm and Arm, and is free to download, with plans to become fully open source later in 2026. For full details, see the Samsung announcement.

Sokatoa and Eclipse Theia

A specialised tool like Sokatoa combining custom views, deep component integration, and backend tooling, would historically have been a natural fit for Eclipse RCP, which has powered similar domain-specific tools for over two decades. With Theia as the next-generation Eclipse tool platform, Samsung was able to build on a modern web technology stack (TypeScript, Node.js, browser-based rendering) while retaining the depth of customisation that made Eclipse RCP successful. The result is a tool that today runs as a desktop application via Electron, but whose architecture is already suited to cloud-based deployment, all while still connecting to low-level backend components like shader compilers and GPU trace processors.

Sokatoa represents a particularly interesting Theia adoption story, because it demonstrates Theia’s capabilities far outside the realm of traditional source code editing. Sokatoa is not an IDE; it is a specialised GPU profiling and debugging environment with requirements that go way beyond a pure code editor.

Standing on the Shoulders of the Platform

Even though Sokatoa is far from a traditional IDE, the team was able to reuse a large portion of what Theia provides out of the box. The basic application frame, the view and panel system, the editor integration (including Monaco), the preference system, the command and keybinding infrastructure, the output view, theming support, and Theia’s client-backend communication layer, all of these were adopted directly and form the backbone of Sokatoa. This foundation gave the team a mature, production-ready starting point, allowing them to focus their engineering effort on the GPU-specific capabilities rather than rebuilding general-purpose tool infrastructure from scratch.

What makes Theia distinctive as a platform is that this reuse does not come at the cost of flexibility. Where Sokatoa’s requirements diverged from a standard IDE, the team could customise deeply, all without forking the platform. That is where the story gets particularly interesting.

Build-Time Extensions: Going Beyond Plugin Boundaries

A key advantage of Theia for the Sokatoa team was the ability to use build-time extensions rather than being limited to a runtime plugin API. This distinction proved critical in several areas.

Most notably, Sokatoa embeds Perfetto, Google’s system-level tracing tool, as a deeply integrated, native component of the application. This goes well beyond simply wrapping an external tool in an iframe; Perfetto is fully embedded into the Sokatoa workbench. Achieving this level of integration required the power of build-time extensions that Theia offers.

Similarly, the team was able to fully remove unwanted IDE features: commands, preferences, views, and only keep what Sokatoa actually needs, using Theia’s dependency injection system. Sokatoa is not an IDE with extra panels bolted on; it is a purpose-built tool where everything that doesn’t serve GPU profiling has been stripped away. The team even fully removed the traditional file navigator and replaced it with a custom UI that abstracts from the underlying workspace concept and focuses entirely on the logical structure of GPU profiling workflows.

Native Views and Composable UI

One of the most significant architectural advantages of building on Theia was the ability to build everything as native Theia views. In Sokatoa, everything behaves like a native view, including how data is handled and passed around between components. The UI and data model live in the same application framework, which eliminates overhead and significantly simplifies the architecture, particularly important for a data-rich tool like a GPU profiler.

The ability to compose existing UI elements freely also proved valuable. For example, Sokatoa embeds a full Monaco editor instance inside other views, such as the shader editor, without having to reinvent the editor integration. Theia doesn’t just offer integration points; it puts its whole toolkit at your disposal.

Client-Backend Architecture

Sokatoa takes full advantage of Theia’s client-backend architecture. The tool packages a number of backend processes that run on the server side, including Perfetto’s trace processor shell, GFXReconstruct tools, and shader compilers. When shaders are compiled, the output is surfaced through Theia’s output view; the same applies to GFXReconstruct tool output. This means the external tools are integrated natively into the application rather than running as disconnected processes.

This architecture would be difficult to replicate in a plain web application, where running backend tools alongside the frontend is not straightforward. Theia’s built-in support for backend services and the communication layer between frontend and backend made this integration natural.

Why Not a VS Code Extension?

Given the overlap between Theia and VS Code in the broader ecosystem, it’s worth briefly noting why a VS Code extension would not have been sufficient for Sokatoa. VS Code extensions cannot remove built-in features, limiting the ability to create a truly purpose-built tool. Extension UIs run inside webviews, requiring the data model to be separated from the UI and communicated through a bridge, adding complexity and latency that becomes problematic for data-intensive profiling workflows. And deep native embedding of components like Perfetto would have been very difficult to achieve through the extension API. Theia’s build-time extension model, dependency injection, and native view architecture provided the full control needed to build Sokatoa.

Contributing Back: Headless Plugins

The Sokatoa team didn’t just consume Theia: they contributed a significant new capability back to the platform. They developed and contributed an entirely novel plugin mode: headless plugins. This new plugin role enables plugins that extend and interact only with the Theia backend, without being scoped to any frontend connection.

Theia’s architecture made it relatively straightforward to implement headless plugins in a way that fits naturally without disturbing the existing system. The collaboration between the Samsung and Theia teams on this core and somewhat complex component was highly productive, a testament to the openness of the Theia project.

Headless plugins are now a permanent part of the Theia platform, available to all adopters, a clear example of the mutual benefits that arise when adopters actively engage with the ecosystem.

Runtime Extensibility: Extension-First Architecture and Backend Plugins

While Sokatoa’s own features are built using Theia’s powerful build-time extension model, the tool also leverages Theia’s runtime extensibility for third-party integration. From day one, Sokatoa was designed with an extension-first architecture, allowing GPU vendors, third-party tool developers, and game studios to build custom extensions, installable at runtime, for additional metrics, analysis panels, and workflow automation.

Theia’s plug-in architecture was particularly well positioned for this requirement: it enabled Samsung to provide a clean extension model for third parties to add device- and platform-specific capabilities to the product. Given that Sokatoa supports not only Samsung’s Xclipse GPU but also GPUs from Qualcomm and Arm, this runtime extensibility is essential for the tool’s cross-vendor strategy.

The headless plugins contributed by the Sokatoa team (see above) are another form of runtime extensibility: they enable backend-only plugins that can be installed at runtime without requiring a rebuild of the application.

Early Feedback from the Industry

Early access partners across the Android graphics ecosystem have validated Sokatoa’s impact. Engineers at Supercell praised the side-by-side trace comparison for quickly isolating problem areas. Feral Interactive highlighted its intuitive workflow and stability compared to other GPU profiling tools. Unity’s graphics product team shared positive feedback on the quality of the GPU data Sokatoa provides. For the full testimonials, see the Samsung announcement.

Sokatoa and the Eclipse Theia Ecosystem

Sokatoa is a powerful demonstration that Theia’s value extends well beyond code-centric IDEs. It validates a core design goal of the Theia platform: to be a foundation for building any kind of tool, including those that deviate significantly from the traditional IDE workbench layout and feature set. From embedded microcontroller IDEs (Arduino, TI Code Composer Studio) to industrial automation platforms (logi.CLOUD) to now GPU profiling and debugging, the breadth of Theia’s adopter ecosystem continues to grow.

What makes the Sokatoa story particularly noteworthy is the depth of customisation involved, all achieved without forking the platform. Samsung removed the navigator, replaced the workspace concept, embedded Perfetto natively, contributed an entirely new plugin mode, and runs a suite of backend tools through Theia’s server architecture, all while maintaining an extension-first design for third-party GPU vendors. The result is a modern, web-technology-based tool that runs on the desktop today and is architecturally ready for cloud deployment, yet connects seamlessly to low-level GPU tooling. This is only possible because Theia is a true platform that puts its entire toolkit at the adopter’s disposal, rather than restricting them to a predefined extension API.

Samsung’s choice to build Sokatoa on Theia also carries strategic significance for the broader ecosystem. It demonstrates that Theia is trusted by one of the world’s largest technology companies to underpin a tool that is critical to their GPU developer engagement strategy. And as Sokatoa moves toward open source, it will create new opportunities for community contributions and for other adopters to learn from Samsung’s approach to extending Theia for non-traditional use cases.

We hope you enjoyed this adopter story, and we look forward to reading yours.