What features does the Compiler Explorer interface offer?

Updated

Compiler Explorer's interface is built around a simple loop: you type source code in an editor pane, and the site compiles it and shows you the output — most commonly assembly — in a pane beside it. Around that core, the UI adds view modes, compiler and execution controls, output filters, and a set of layout and session tools. The sections below cover what each area does and when you would reach for it.

Core layout: editor and output panes

The default view is a split screen. The left side holds the source editor; the right side holds the compiler output. Each pane has its own toolbar, and the divider between them can be dragged to resize.

The editor toolbar includes:

  • Source Editor — the standard code editing view.
  • Diff View — compares two versions of the code side by side, useful when you want to see exactly what changed between two attempts.
  • Tree (IDE Mode) — presents the code in a tree-style navigation layout rather than a flat file.
  • Vim — a Vim keybinding mode for the editor.
  • CppInsights and Quick-bench — additional editor-side tools listed in the toolbar.

Above the panes you'll find Add... (to add a new compiler or tool), More, Settings, Reset UI layout, Reset code and UI layout, Open new tab, and History. The two reset options matter if you have rearranged panes or changed settings and want to get back to a known state — the first resets only the layout, the second also clears your code and settings.

Adding compilers, tools, and libraries

Add new... under the compiler selector lets you attach another compiler to the same source. This is the standard way to compare how, say, two different compiler versions or optimization levels treat identical code — each compiler gets its own output pane.

The same area exposes Add tool..., which attaches analysis tools to a compiler. The available tools depend on the language and compiler selected; the interface states plainly that "the current language or compiler does not support this tool" when a tool isn't applicable. Tools visible in the interface include:

  • Opt Remarks — optimization remarks from the compiler.
  • Stack Usage
  • Preprocessor — the preprocessed source after macro expansion and includes.
  • AST — the abstract syntax tree.
  • LLVM IR, ClangIR, Opt Pipeline
  • Rust MIR, Rust HIR, Rust Macro Expansion
  • GHC Core, GHC STG, GHC Cmm (Haskell)
  • Lean C Output
  • Clojure Macro Expansion
  • Yul (Solidity IR)
  • GCC Tree/RTL, GNAT Debug Tree, GNAT Debug Expanded Code
  • Control Flow Graph
  • Claude Explain

Libraries and Overrides sections let you pull in installed libraries and override compiler or library settings for a given pane.

Compiler options, execution, and input

Each compiler pane has an Output... menu that controls what the compiler produces:

  • Compile to binary object
  • Link to binary
  • Execute the code

Alongside it are toggles such as Intel asm syntax, Demangle identifiers, Verbose demangling, and a Filter... group that hides or shows Unused labels, Library functions, Directives, Comments, Horizontal whitespace, and Debug intrinsics. These filters are what keep assembly output readable when you only care about your own code.

For running programs, the Compiler options for execution area collects Compilation Arguments, Stdin, and Runtime tools. Stdin is where you supply input the program reads at runtime; Runtime tools attach instrumentation to the executed binary. A Download control lets you pull down the compiled artifact.

Verbose compiler flags can be edited in a separate window via Open a new window to edit verbose compiler flags, which is easier than fighting with a single-line input for long flag strings.

Output pane controls

The output pane mirrors the editor's flexibility. It offers Wrap lines, Select all, and language-appropriate formatting actions such as Apply clang-format where relevant. For IR-style outputs there are additional options — for example Demangle Symbols, -fno-discard-value-names, Show Optimized, and filter groups for Hide Debug Info, Hide Instruction Metadata, Hide Comments, Hide Declarations, and Hide Library Functions.

The Control Flow Graph tool has its own option set, including Output, Flat, and filter toggles. GCC's tree/RTL views expose Raw Dump, Slim Dump, GIMPLE, Frontend Syntax, Addresses, Alias, Basic Blocks, Line Numbers, Pass Details, Pass Stats, Unique IDs, and Virtual Operands — enough granularity to inspect individual optimization passes.

Session, sharing, and layout tools

  • Save/Load — persist and restore your current setup.
  • History — step back through previous states.
  • Templates with Start / Previous / Next — start from a prepared example and page through them.
  • Share — produces a Short Link, a Full Link, or an Embed in iframe snippet.
  • Default Font Scale — adjusts text size across the UI.
  • Reset UI layout / Reset code and UI layout — return to defaults.

The footer links to Policies, Cookie policy, Privacy policy, Installed libraries, Wiki, How it works, Report an issue, Contact the author, Statistics, Changelog, and Version tree, plus community and support channels (Mastodon, Bluesky, GitHub, mailing list, and sponsorship options).

A note on JavaScript

The interface depends on JavaScript. The site notes that "without Javascript the regular website is not functional" and provides a link to a noscript version for users who need it. If you land on a page that appears inert, that's the likely cause.

Choosing what to use

If you just want to see assembly for a snippet, the default editor-plus-output layout is all you need. Reach for Diff View when comparing two code versions, Tree (IDE Mode) when navigating a larger example, and multiple compilers when you care about portability or version differences. The analysis tools (AST, IR, Control Flow Graph, optimization remarks) are for when the assembly alone doesn't explain what the compiler did. Execute the code with Stdin and Runtime tools turns the site into a quick scratchpad for running small programs, and Share links make any of these states reproducible for someone else.