Asm Lens

See what your code compiles to without leaving the editor. Asm Lens puts the instruction count of every function above it, opens the function's assembly next to your code, and links the two: hover a source line to see its instructions, hover an instruction to see its source line.

It compiles with Compiler Explorer (no setup) or with the compiler installed on your machine (nothing leaves it). C and C++ get the full treatment, including local headers, header-only code and templates. Rust, Go, Python, Zig, Swift, D and Fortran are supported too.

Features

• Instruction counts as CodeLens above every function: 12 instructions · GCC 15.2 · -O2. Template functions show every instantiation (3 instantiations · 4 / 6 / 9 instructions).
• Assembly view next to the editor. Click a count to open it; it follows the cursor from function to function.
• Two-way highlighting, like Compiler Explorer: each source line and its instructions share a color. Hover or click a source line to highlight its instructions; hover an instruction to highlight its source line (and the exact token, when the compiler reports a column). Everything else stays as it is (asmLens.dimOtherLines fades the rest instead). Hover a function's signature to preview its whole assembly.
• Every function, including unused ones: methods defined inside a class, and static, inline and constexpr functions get their own counts even when nothing in the file calls them, with every compiler (asmLens.emitUnusedFunctions).
• Headers work: analyze a header on its own, or analyze a .cpp and open the headers it includes. Functions defined in headers get counts too, including code inlined into callers.
• Templates on demand: click Instantiate… above a template, type the template arguments (int, float, 4, std::vector<int>), and see the code for exactly that type.
• Robust against real projects: local headers are found and uploaded the way a compiler would find them; a missing header is replaced by an empty file; a function that does not compile is skipped and marked Not compiled, and the rest is analyzed.
• Remote or local, per project or per compiler, on Windows, Linux and macOS. Local mode can take each file's compiler and flags from your build's compile_commands.json.
• Any compiler on Compiler Explorer: GCC, Clang, MSVC (x64, x86, ARM64, ARM32), ICX/ICC, and the cross compilers for ARM, RISC-V, MIPS, PowerPC, AVR, MSP430, Z80, 6502 and more. One set of flags serves them all: -O2 -std=c++20 reaches MSVC as /O2 /std:c++20 /EHsc.
• Fast, and visibly working: a progress notification shows each step (finding headers, compiling, retrying around errors) with a Cancel button; the status bar and the CodeLens spin while it runs. Unchanged code is answered from a cache, and Compiler Explorer is asked for compact replies.
• Live while you edit: results stay on screen and move with the text; only the functions you change show Updating…, and the file is analyzed again in the background when you pause typing.

Quick start

1. Install the extension (or search for Asm Lens in the Extensions panel) and open a C, C++, Rust, Go, Python, … file.
2. Click Analyze with Asm Lens above any function (or run Asm Lens: Analyze Current File, or right-click in the editor).
3. Click a count to open the assembly view. Hover lines in either view.

While it compiles, a notification shows what is happening and lets you cancel. After that the counts follow your edits by themselves (see Editing).

Editing

You do not need to analyze again after a change:

• Results stay visible while you type. Counts below an edit move with the text; a function you change shows Updating… (or Changed since the last analysis), the others keep their numbers.
• When you pause typing (asmLens.reanalyzeDelayMs, 1 s) the file is analyzed again in the background, with a spinner in the status bar instead of a notification. A newer edit cancels a compile of the older text. The open assembly view switches to the new code of the same function.
• Editing a header updates the .cpp whose results it shows.
• The whole file is compiled each time, because that is the smallest unit a compiler works on, and a change to one function can change every function it is inlined into (or, for a type or a #define, everything after it). Compiling less would give wrong numbers. What is skipped is everything else: unchanged code is answered from a cache, and replies are kept small.

Set asmLens.reanalyzeOn to save to compile only when you save, or never to compile only when you ask.

By default the file is compiled on godbolt.org with GCC 15.2 and -O2, in Intel syntax. Choose another compiler with the compiler name in the status bar (bottom right) or Asm Lens: Select Compiler. To change flags, include folders and so on for a project, run Asm Lens: Open or Create Project Config (see .asm-lens.json).

Remote and local mode

Choose the mode in .asm-lens.json ("mode": "local"), per compiler ({ "id": "...", "mode": "local" }), or for every project with the asmLens.mode setting. The status bar shows which one is active (clang++ (local) or the Compiler Explorer compiler's name).

Local mode for C/C++ runs <compiler> <flags> -I<includePaths> -iquote <file folder> -S -g -o - -x c++ - with your unsaved text on standard input, then c++filt to demangle names. Asm Lens never runs your program and never builds the rest of the project.

Assembly syntax. Asm Lens shows Intel syntax and picks the flag for it itself, because the right flag depends on the compiler: on Compiler Explorer the server adds it per compiler; locally Asm Lens asks the compiler what it is (--version, -dumpmachine) and adds -masm=intel (GCC) or -mllvm -x86-asm-syntax=intel (Clang) for x86 targets only. A -masm=... in your flags is therefore not passed on (MSVC and non-x86 compilers reject it); write -masm=att to get AT&T syntax instead. If a compiler rejects any other flag (cc65: Unknown option: -O2), that flag is left out, the file is compiled again, and the output says so.

Flags for MSVC. Write your flags once, the GCC/Clang way. For MSVC and clang-cl, Asm Lens translates the common ones (the output lists each translation) and leaves the rest as written, so flags you write for MSVC (/O2 /std:c++latest) are kept as they are:

C++ also gets /EHsc, as Visual Studio projects do, unless you give an /EH option. The other way round, MSVC flags (/O2, /std:c++20, /W4, /DNAME) given to GCC or Clang are translated too.

Functions nothing calls. A compiler leaves out a function defined inside a class, or a static, inline or constexpr one, when nothing in the file uses it (and often when every call was inlined). To show its code anyway, the copy that is compiled marks such functions __attribute__((used)) on the same line (MSVC: a line after the end of the file takes each one's address). Your file is not changed, and if the marked copy does not compile, the file is compiled as written. Set asmLens.emitUnusedFunctions to false to see only what the compiler emits on its own.

compile_commands.json (local mode)

With "compileCommands" in .asm-lens.json (or the asmLens.compileCommands setting), each file is compiled the way your build compiles it: with the compiler and flags of its entry in the compile_commands.json database that CMake (-DCMAKE_EXPORT_COMPILE_COMMANDS=ON), Bear, Meson and others write.

{
  "mode": "local",
  "compileCommands": "build/compile_commands.json",   // or several: ["build/a.json", "build/b.json"]
  "compilers": [{ "id": "local", "extraFlags": "-DASM_LENS" }]
}

• The entry's compiler runs in the entry's directory, with your editor text on standard input. The entry's flags are used without -c, -o <file>, -MD/-MMD/-MF/-MT/-MQ, -Werror*, -x <lang> and the source path; Asm Lens adds -S -g -o - -w -x c++ - (or -x c) and the syntax flag, and then the active compiler's extraFlags. Compiler launchers (ccache, sccache, distcc) are skipped.
• A file without its own entry (a header, a new file) uses the entry of a source file that includes it (one you analyzed, else one found by searching the nearest folders first), else an entry in the same or the nearest folder. Without any database entry, the usual flags, defines and includePaths apply.
• The database is read again whenever it changes; Asm Lens: Reload Compile Commands forces it. The output shows the final command and which entry was used.
• Local mode needs a GCC- or Clang-compatible compiler; an MSVC (cl.exe, clang-cl) database is reported, and remote mode with an MSVC compiler from Compiler Explorer is the way to see its code.

Headers and templates

Analyzing a header on its own. A header usually compiles to nothing: an inline or static inline function that nothing calls is dropped, and a template is just a pattern. When you analyze a header (.h, .hpp, .hxx, .hh, .inl, .ipp, .tpp, …), Asm Lens marks every non-template function in it __attribute__((used)) (only in the copy that is compiled, keeping every line in place), so each one is emitted and gets a count: free functions, static inline functions, and member functions defined inside classes.

Templates. Above every template function, and every member function of a class template, there is an Instantiate… CodeLens. Click it and type the template arguments:

• square<T>: type int and Asm Lens compiles square<int>;
• mx::Box<T>::twice(): type double and Asm Lens compiles template struct mx::Box<double>;, which gives the code of every member of Box<double>;
• a member template of a class template asks for both argument lists.

The requests are added after the file's last line, so line numbers do not change. They are remembered per file (shown in a CodeLens at the top of the file; click it to remove some) and compiled every time you analyze that file. A request that does not compile (a misspelled type, for example) is removed and the compiler's message is shown. Template constructors cannot be instantiated this way; use them from a .cpp file instead.

Analyzing a .cpp and then opening its headers. Every header the .cpp includes shows the result of that analysis (· via user.cpp): functions that were emitted show their counts, and code that was inlined into the .cpp's functions shows as N inlined instructions · used in M function(s). A function the .cpp does not use says Not used by user.cpp; click that to analyze the header itself.

For each function, the newest analysis that has code for it decides. So analyzing a .cpp does not hide what the header's own analysis found, as long as both used the same compiler, and templates you instantiated keep showing the code you asked for.

Languages

For languages other than C and C++, the default remote compiler is Compiler Explorer's default for that language. Choose another with Select Compiler, or list one in .asm-lens.json with its "language". The top-level flags, defines, includePaths and compiler are C/C++ settings and are not used for other languages; give those compilers their own flags and compiler.

VS Code has built-in support for C, C++, Objective-C, Rust, Go, Python and Swift files. For Zig, D and Fortran, install an extension that adds the language (for example Zig Language, code-d or Modern Fortran).

Project configuration: .asm-lens.json

Put a .asm-lens.json in the project root (Asm Lens: Open or Create Project Config creates one from a template). It is found by walking up from the analyzed file, also as .vscode/asm-lens.json. It accepts comments and trailing commas, editing it takes effect immediately, and problems in it are listed in the Asm Lens output channel. VS Code validates it as you type.

Settings are taken in this order: the active compiler's own entry, then the top level of .asm-lens.json, then the VS Code settings.

Example: Compiler Explorer, several compilers

{
  "compilers": [
    { "id": "g152", "name": "GCC 15.2", "flags": "-O2 -masm=intel" },
    { "id": "clang1910", "name": "Clang 19", "flags": "-O3 -march=native" },
    { "id": "cg152", "name": "GCC 15.2 (C)", "language": "c" }
  ],
  "includePaths": ["include", "src/generated", { "path": "third_party", "recursive": true }],
  "defines": ["NDEBUG", "USE_SIMD=1"],
  "buildFolders": ["build", "out"]
}

Example: local compiler

{
  "mode": "local",
  "compiler": "g++-14",              // or "clang++", "C:/msys64/ucrt64/bin/g++.exe", "./tools/bin/g++"
  "flags": "-O2 -std=c++20 -march=x86-64-v3",
  "includePaths": ["include"]
}

Example: mixing languages and modes

{
  "mode": "local",
  "compilers": [
    { "id": "local-gcc", "name": "GCC", "compiler": "g++", "flags": "-O2" },
    { "id": "r1990", "name": "Rust 1.99", "language": "rust", "mode": "remote", "flags": "-C opt-level=3" },
    { "id": "py", "name": "Python 3.12", "language": "python", "compiler": "python3.12" }
  ]
}

All options

Each object in compilers may have:

VS Code settings

Commands

When code does not compile

Projects rarely compile from a single file without their build system. Asm Lens recovers instead of giving up:

1. A flag the compiler does not accept: left out (the output says which).
2. Missing header: retried with that header replaced by an empty file.
3. A function that then fails (it used something from that header): the function is blanked out (line numbers stay the same) and the rest is compiled again. Its CodeLens says Not compiled.
4. Each retry is one more compile, up to asmLens.maxRecoveryAttempts.

Only the copy that is compiled changes, never your files. Everything that was skipped is listed in the Asm Lens output. If a header is not on any include path, the workspace is searched for it (case-insensitively): first your normal folders, then build output folders, where generated headers live. If that is not enough, add the folders to includePaths, the needed defines, or switch to local mode, where your own compiler and system headers are used.

Troubleshooting

• "Instantiations not compiled yet": instantiations are saved per file but compiled only when that file itself is analyzed. Click the CodeLens.
• "No code emitted": the function is a template that was never instantiated (click Instantiate…, or analyze a file that calls it), or asmLens.emitUnusedFunctions is off and nothing uses it.
• Local mode on macOS: errors in C++11 code ('auto' type specifier is a C++11 extension): Apple clang 14 and older compile C++98 by default. Asm Lens then adds -std=gnu++17 (the default of current compilers and of Compiler Explorer) and says so in the output; put a -std=... in your flags to choose.
• Rust shows nothing: only pub functions (and what they use) are compiled into a library.
• Zig shows nothing: mark functions export.
• Local mode: "g++ was not found": install a compiler or set "compiler" (or asmLens.localCompiler) to its full path. On Windows, MinGW-w64 (MSYS2) and LLVM both work; MSVC's cl.exe does not.
• Hover highlighting does nothing: the compiler gave no line information for that function. All defaults include it; flags such as -g0 remove it.
• A compiler id does not work: ids differ between Compiler Explorer servers and change over time; use Select Compiler → Browse.
• "godbolt.org did not answer within 60 s, twice": the public Compiler Explorer is shared, and at busy times a compile can wait in its queue (the progress shows the seconds meanwhile). Asm Lens asks once more by itself; if it still gets no answer, analyze again in a moment, raise asmLens.requestTimeoutMs, or use local mode.
• "godbolt.org is limiting how often it compiles (HTTP 429)": the public server allows a limited number of compiles per minute. Automatic re-analysis pauses for 30 seconds; set asmLens.reanalyzeOn to save if you hit this often, or use local mode or your own Compiler Explorer (baseUrl).
• Some compilers need their own flags: for example GCC for 6502 wants --target=..., and z88dk a +target first argument. Give such a compiler its flags in .asm-lens.json.
• See Asm Lens: Show Output for the exact command, flags and compiler messages.

Privacy

In remote mode the analyzed file and the local headers it includes are sent to the Compiler Explorer server in baseUrl (godbolt.org by default; see its privacy policy). Use local mode, or a self-hosted Compiler Explorer, for code that must stay private. In local mode nothing is sent anywhere.

Development

npm test                 # unit tests, recorded Compiler Explorer responses, and every local compiler found
npm run test:remote      # the same against the live godbolt.org
node test/run.js --record   # refresh the recorded responses (test/fixtures/ce)
node test/tools/survey-ce.js c++   # one compiler of every Compiler Explorer family (c or c++; network)
node test/tools/stress-headers.js  # the C/C++ scanner on large real-world headers (network, clang)
npm run package          # build asm-lens-<version>.vsix (needs network for npx)

There are no runtime dependencies and no build step: the extension is plain JavaScript in src/:

Every push builds the .vsix on GitHub Actions (tests on Windows, Linux and macOS first); it is attached to the workflow run.

To release, set the new version in package.json and push a matching tag such as v0.8.3. That creates a GitHub release with the .vsix and publishes it to the Visual Studio Marketplace with Trusted Publishing, so no token is stored. It needs a policy for this repository and build-vsix.yml on the publisher's Trusted Publishing page. Open VSX is published too when the OVSX_PAT secret is set.

License

MIT