# Compiler Explorer: Interactive Assembly Output for 30+ Languages in the Browser

> Compiler Explorer is an open-source web application that compiles code in real time and displays the resulting assembly output side by side with the source. It runs at godbolt.org and handles more than 3,000,000 compilations per week, supporting C, C++, Rust, Go, Java, Python, and more than thirty other languages with multiple compiler versions per language.

**compiler-explorer/compiler-explorer** — Run compilers interactively from your web browser and interact with the assembly

- Repository: https://github.com/compiler-explorer/compiler-explorer
- Website: https://godbolt.org
- Stars: 19,103 · Forks: 2,122
- Language: TypeScript
- License: BSD-2-Clause
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/compiler-explorer-compiler-explorer

## What Compiler Explorer Does and Who Uses It

Compiler Explorer is an interactive compiler exploration website. You write code in an editor pane and the tool compiles it in real time, showing the resulting assembly in an adjacent pane. The assembly updates as you type. The primary use case is understanding how a compiler translates a specific C++, Rust, or Go construct into machine instructions, and how that translation changes between compiler versions or optimization flags.

The project started in 2012 as a tmux session with vi in one pane and watch gcc -S foo.cc -o - in the other. It was created by Matt Godbolt to show how C++ constructs become assembly code. It is now a public website at godbolt.org serving over 3,000,000 compilations per week.

Beyond assembly output, the site supports multiple tools and visualizations: execution output, control flow graphs, memory layout views, and diff comparisons between two compiler configurations. The UI layout uses a configurable panel system built on GoldenLayout, so users can arrange editor, compiler output, and tool panels in any combination.

The repository covers more than thirty languages, including C, C++, C#, F#, Rust, Go, D, Haskell, Swift, Pascal, ispc, Python, Java, and others listed in the /api/languages endpoint. Multiple compiler versions are available for most languages, which makes it possible to compare how a language feature is handled by an older and newer release of the same compiler.

## How the Compilation Pipeline Works

Compiler Explorer is written in TypeScript and runs on Node.js. The server receives a compilation request from the browser, invokes the target compiler with the user's code and flags, captures the assembly output, and returns it to the client for display. The server architecture uses AWS services (DynamoDB, EC2, S3, SQS, SSM) for the hosted deployment, as reflected in the package.json dependencies.

The configuration system lives in the etc/config directory. Config files use key=value pairs. A file named {type}.local.properties overrides values in {type}.defaults.properties. The README notes that local.properties files are in .gitignore, so local overrides do not get committed when pulling updates.

Some languages require extra tools to demangle their output. Rust, D, and Haskell demangling tools are maintained in a separate compiler-explorer-tools repository rather than in the main codebase.

The Monaco editor is used for the code input pane, and the package.json shows monaco-editor and monaco-vim as dependencies. The client-side build uses webpack. The package.json also lists a Model Context Protocol SDK dependency, which appears as @modelcontextprotocol/sdk, suggesting the site has some integration with MCP tooling.

## Running Compiler Explorer Locally

Running a local instance requires a compatible version of Node.js. The README states that the required version is pinned in .node-version, and the build system accepts anything newer. It looks for node on the PATH first, covering system installs and version managers with shell integration such as fnm, asdf, nodenv, volta, and nvm. To force a specific installation, point the NODE_DIR environment variable or make parameter at it.

On Linux, starting a local instance is:

```bash
make
```

This installs third-party libraries using npm and starts Compiler Explorer on port 10240. The interface is then available at http://localhost:10240/.

To load only one language and reduce startup time, pass the language id as an argument. For C++ only:

```bash
make EXTRA_ARGS='--language c++'
```

Multiple --language arguments are accepted. Language ids and aliases are defined in lib/languages.ts.

For development, the README recommends:

```bash
make dev
```

This enables automatic reloading on file changes and shorter startup times. Alternatively, npm run dev works on machines where make dev does not.

Configuring compilers for a self-hosted instance is documented in docs/AddingACompiler.md. The hosted site at godbolt.org provides a large set of installed compilers; a local instance starts with only the compilers available on the host system.

## Sharing Sessions, Linking Libraries, and Multi-Compiler Comparisons

One of the more practical features of Compiler Explorer is the ability to share a session as a URL. A shared link encodes the source code, compiler selection, and flags, so a reviewer can open exactly the same configuration in a browser. This makes it useful for reporting compiler bugs, demonstrating an optimization pattern, or attaching evidence to a code review comment.

The tool supports linking libraries into compilations on the hosted site. The README notes that library requests are accepted through the GitHub issue tracker. Boost, for example, is a commonly linked library on godbolt.org. Local instances need those libraries installed on the host.

Multiple compilers can be compared in a single session. The configurable GoldenLayout panel system allows two or more compiler output panes side by side, each showing the output from a different compiler or a different set of flags applied to the same source. This is useful for regression checks when upgrading a compiler version.

The repository includes an examples directory with subdirectories for Ada, Algol68, assembly, C, C++, Cargo, COBOL, and many other languages. These serve as reference inputs for testing and demonstration.

## Where Compiler Explorer Does Not Fit

Compiler Explorer is not a general-purpose development environment. It does not persist files between sessions by default. It does not support multi-file projects through a standard interface: the README mentions that multiple files is a listed search query, but the core tool is oriented around single-source compilation with a visible assembly output. Complex build systems with many translation units are not the target use case.

The tool compiles code but does not always execute it. Execution output is available for some configurations on the hosted site, but arbitrary network code, file system access, and long-running processes are outside what the site supports.

Self-hosting shifts the compiler management burden to the operator. The hosted godbolt.org instance maintains a large set of compiler versions across many languages. A self-hosted instance starts with only what is installed on the host machine. Adding a compiler requires following the AddingACompiler.md guide and configuring the correct properties file.

For engineers who need to explore compiled output across many compiler versions without self-hosting, the alternative is setting up a local toolchain matrix, which requires installing each compiler version separately and writing the comparison scripts manually. Compiler Explorer provides this through a browser interface at no setup cost, but that convenience comes with the constraints of the hosted environment.

## Project Origins, Maintenance, and Licensing

Compiler Explorer was started in 2012 by Matt Godbolt and has grown substantially since then. The last push to the repository was on 2026-09-27. The codebase is in TypeScript with a Node.js server and uses biome for linting, vitest for unit tests, and Cypress for end-to-end tests, as shown by the top-level configuration files.

The project follows a code of conduct and accepts contributions through GitHub pull requests. The CONTRIBUTING.md file documents the node version requirement and the development workflow.

The project is BSD-2-Clause licensed. The README mentions financial support options through Patreon, GitHub Sponsors, and PayPal, which is relevant context for teams evaluating long-term reliance on the hosted site.

A roadmap at docs/Roadmap.md gives insight into planned directions for the project. Several conference talks are linked in the README for teams that want a deeper introduction to the tool's capabilities and history.

## Conclusion

Compiler Explorer is the right tool for any engineer who needs to see what a compiler produces for a specific code pattern, compare outputs between compiler versions, or learn how high-level constructs map to machine instructions. It is not a full development environment: you cannot save files, run network code, or manage multi-file projects through the standard interface. Teams that want to self-host should verify they have a compatible Node.js version and local compiler installations, since the hosted site provides compilers but the self-hosted instance requires you to install them separately. The last push was on 2026-09-27 under the BSD-2-Clause license.

## FAQ

### What does Compiler Explorer do?

Compiler Explorer compiles code in real time and displays the resulting assembly output alongside the source. It supports more than thirty languages with multiple compiler versions, and shows tools such as execution output, control flow graphs, and diff comparisons.

### Who created Godbolt Compiler Explorer?

Compiler Explorer was started in 2012 by Matt Godbolt. The name Godbolt comes from his surname; the hosted site is at godbolt.org.

### How do I run code in Compiler Explorer?

Write your code in the source pane on godbolt.org and select a compiler and language. The tool compiles in real time and shows assembly output in the adjacent pane. Execution output is available for some configurations.

### How do I see assembly output in Compiler Explorer?

The assembly output pane appears by default next to the source editor. As you type, the compiler recompiles and updates the assembly. You can adjust optimization flags in the compiler options field to see how they affect the output.

### Is Compiler Explorer the same as Godbolt?

Yes. Compiler Explorer is the name of the project and the open-source codebase. Godbolt refers to the hosted instance at godbolt.org, named after the project's creator, Matt Godbolt.

## Sources

- [compiler-explorer/compiler-explorer on GitHub](https://github.com/compiler-explorer/compiler-explorer)
- [Issues](https://github.com/compiler-explorer/compiler-explorer/issues)
- [License: BSD-2-Clause](https://github.com/compiler-explorer/compiler-explorer/blob/main/LICENSE)
- [Project website](https://godbolt.org)
- [README](https://github.com/compiler-explorer/compiler-explorer/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/compiler-explorer-compiler-explorer