CodeGlass traces every executed instruction, allocation, and runtime event back to the lines of Julia code responsible, so you can locate performance and memory issues from a single run, without rewriting your code or creating a minimum working example.
Understanding performance or memory issues in Julia often means isolating parts of your application, turning them into a minimum working example, and running them repeatedly with different tools.
This is time-consuming, and it often does not reflect what actually happens in the full application. Some issues only show up during real runs, or disappear once the code is isolated.
CodeGlass instruments your application and collects detailed runtime information during a normal execution. Instructions, allocations, and events are recorded and linked directly to the lines of Julia code responsible.
You can start a run of your application and inspect the parts of your code that are responsible. Without rewriting code, extracting examples, or rerunning multiple times.
Traditional profiling tools rely on sampling: they periodically inspect the state of a running application and infer where time is spent. While this approach is lightweight, it provides only a partial view of what actually happened during execution.
CodeGlass traces execution as it happens. Instead of sampling, it records all instructions, allocations, and runtime events, and relates them back to the code that produced them. Because this information is collected during execution, you can inspect your application while it is running.
To make this possible, CodeGlass integrates with the Julia runtime through an instrumentation layer that captures execution behavior as it occurs. This allows runtime information to be collected and linked directly to the corresponding parts of your code. We are working with the Julia community to upstream the instrumentation layer we built, so that over time it can become part of the standard ecosystem.
The capabilities of the instrumentation layer are not limited to the features shown here. It provides a foundation for analyzing a wide range of runtime behavior and supports more specialized use cases beyond the features currently available.
Inspect how functions behave in terms of execution and memory. See how often functions are called, how long they take, what they allocate and if they deallocate. Whether they are part of your code, internals or packages. From here, you can drill into individual functions to understand what happens during execution.
See what actually happens when a function executes. CodeGlass reconstructs the control flow of your function during execution and presents it in a readable, Julia-like code. You can inspect which parts of a function take time, what they allocate (types and sizes), and how often they are executed down to branches and loops. From there, you can drill into detailed statistics, see which functions are called and how dynamic dispatches are resolved at runtime, and understand how the function behaves at runtime.
CodeGlass continuously collects runtime data during execution. To help you get better insight into specific parts of your code, you can define recording windows within a run and analyze only that part. This makes it possible to isolate the behavior you care about, such as a short computation within a longer process or processes that get slow over time, without rerunning your application. You can inspect each window on its own or compare it with others, using the same views as for the full execution.
CodeGlass shows not only what was allocated, but also what was reclaimed by the garbage collector. You can inspect reclaimed objects per garbage collection cycle and trace them back to the functions and control flow parts that allocated them. This makes it possible to see which allocations are reclaimed and which remain in memory over time, and to relate memory behavior directly to the code responsible.
CodeGlass collects runtime data in real time, allowing you to inspect your application while it is running. You can follow execution flow across threads and see which parts of your code are active, based on traced execution. This makes it easier to understand long-running processes, observe behavior as it happens, and move directly from live execution into detailed inspection of the functions involved. It also helps identify where execution is stalled, without interrupting the application.
CodeGlass captures exceptions during execution and presents them in the context of your application’s runtime behavior. You can inspect exception messages, see how the call stack was unwound, and trace where an exception occurred and where it was handled. Exceptions are linked back to the functions and control flow where they happened, allowing you to understand not just that an error occurred, but how execution led to it and how it propagated through your code.
CodeGlass is designed to work on real applications, not isolated examples. You can run your application as you normally would and inspect its behavior during or after execution, without restructuring your code or simplifying it into a minimum working example.
Because CodeGlass traces execution in detail, it introduces overhead. To keep this manageable, you can control how much data is collected. Data collection can be limited to specific parts of your code, paused and resumed during execution, or configured depending on what you want to analyze.
This makes it possible to focus on the parts of your application that matter, while keeping the application usable in practice.
CodeGlass has been developed for and validated by companies that use Julia for real-world applications, where it is used to diagnose performance and memory issues that are difficult to reproduce or isolate.
CodeGlass is available with a free trial so you can evaluate it on your own applications.
After the trial, individual users can continue with a limited version for personal use at a lower cost. For companies and commercial use, we offer tailored licensing depending on the use case. Contact us to discuss options.
We aim to keep CodeGlass available to individuals, while commercial use supports its development and enables more advanced usage and customization. If you are working on non-commercial projects and need the full version, feel free to contact us.
CodeGlass is a developer driven company. We started building tools as developers who spent a significant amount of time diagnosing performance and memory issues in real applications. Over time, we created tools to better understand runtime behavior and to make these problems easier to solve.
These tools were used across different projects, programming languages and companies, but were never released publicly. While we always considered it, most of them were developed for specific environments or use cases, of companies.
That changed when we started working with the Julia community. We found that many of the same problems existed, and that even a broader version of our tooling could be useful within the ecosystem. After JuliaCon Paris we found the Julia community to be open and engaged, and saw an opportunity to contribute something meaningful back.
Since then, we have focused on making CodeGlass for Julia available as a general tool, while adapting it to work across different environments and use cases. If you need specific information to solve a problem, reach out to us! We might already have the tool, solution, or data.
If you are unsure whether CodeGlass fits your use case, feel free to reach out. We can help you determine if it is a good fit for your application, and your feedback helps improve the tool.