Claude Code plugin
The asmsdk plugin teaches Claude Code this SDK: projects,
references, packages, the NASM rules that decide whether code links, the toolchain, CI and
releases. It comes with three scripts that also work on their own. It is published in the
AsmFoundation's plugin marketplace,
AsmClaudeMarketplace.
/plugin marketplace add AsmFoundation/AsmClaudeMarketplace
/plugin install asmsdk@asmfoundation
Claude loads the skill on its own when a task involves an .asmproj, AsmFoundation.Sdk,
NASM built with dotnet build, assembly NuGet packages, or a linker error from such a build.
You can also call it by name: /asmsdk:asmsdk.
What it knows
Plugin 0.3.0 documents AsmFoundation.Sdk 0.3.0: seven runtime identifiers, NASM for the x64 ones and GNU syntax for ARM64, the C library of every OS, and .NET consumers by RID. Each behavior it states was reproduced by building with an AsmSdk release and its bundled tools, or is verified by AsmSdk's own tests on five build machines; what each output format's NASM accepts was measured directive by directive. For a 0.1.0 or 0.2.0 project, it names each removed setting's replacement. The same knowledge is on this site:
- the project model, and the platforms and runtime identifiers;
- the complete property, item and target reference;
- the linking rules, with the exact error each prevents;
- .NET, Python and C interop;
- the toolchain, CI and troubleshooting.
The scripts
The scripts are in the plugin's skills/asmsdk/scripts/ folder. They need only Python 3.8
or later, with no packages.
new_asmproj.py
Scaffolds a project that builds every RID it lists on the first dotnet build:
python new_asmproj.py Hello --kind library --assembly-name hello --sln App.slnx
python new_asmproj.py Tool --kind exe --framework libc
python new_asmproj.py Crc --kind static --package-id Acme.Crc --version 1.2.0 --rids "linux-x64;win-x64"
- What it writes:
- the
.asmproj, withRuntimeIdentifiers: by default every RID the kind can build (all seven; a freestanding program all but macOS, which has none); - a public include file in
include/; - starter sources that follow every linking rule on every OS: a NASM file for the x64 RIDs
through
asmsdk.inc, and a GNU-syntax file for the ARM64 RIDs throughasmsdk-gnu.inc. A freestanding program makes Linux system calls and calls kernel32 on Windows; a libc one callsputs, which takes no variadic arguments (Apple's ARM64 passes those on the stack); - the
global.jsonentry, when missing; - the
.slnxline with the project type GUID.
- the
- Verified: every kind and framework built for all its RIDs with 0.3.0, and the programs ran on Windows x64, Ubuntu, Alpine and Linux ARM64.
- It never overwrites a file. An existing
global.jsongains only themsbuild-sdksentry, and an existing.slnxgains only the new line.
check_asmproj.py
Lints projects and sources for the mistakes that break builds or outputs, with the file, line and fix for each. It exits 1 when it finds an error.
It judges each source for the platforms it is built for: the project's RuntimeIdentifiers
(a project that lists none takes the RIDs of the asm projects that reference it), the
source's file-name qualifier, chosen the way the SDK chooses, and the %ifdef WINDOWS /
LINUX / MACOS guards around each line. A directive that is right on Linux and stops
macOS's NASM is an error there, and a warning when the RIDs are only assumed. With the SDK
package in the NuGet cache, it also checks C library calls against each OS's list.
python check_asmproj.py . # every .asmproj and .slnx under the folder
python check_asmproj.py App.slnx --json
| Codes | What they catch |
|---|---|
ASMPIC001–005 |
per OS: absolute addressing without default rel (Linux .so/PIE, macOS's NASM, Windows' ASM0080); calls and data of another library from a Linux .so without PLT / wrt ..got (within one library, -Bsymbolic binds them); absolute addresses in .text (Linux, macOS's ASM0081); dd label and dq label in read-only sections |
ASMSRC005–022 |
an unwritable .data.rel.ro; a missing .note.GNU-stack on Linux; untyped exports in Linux-only files; keyword symbol names; %include paths NASM won't find; an .asm included and assembled twice; a missing entry symbol; symbols nothing defines (including C library functions outside each OS's list); hidden written after the size; the source selection's errors (ASM0020, ASM0021, ASM0023, ASM0024); sections, symbol types and wrt forms a platform's NASM output rejects (.note.GNU-stack on macOS, :function on macOS, hidden on Windows and macOS, wrt ..plt off Linux); a plain global that a Windows DLL does not export, unless the other OSes hide it (then it is internal, as meant); a symbol internal on one OS and exported on another |
ASMPRJ000–018 |
a setting that 0.2.0 or 0.3.0 removed, with its replacement; no RuntimeIdentifiers (ASM0010); a RID AsmSdk does not build (ASM0011); a freestanding macOS program (ASM0015); a target framework other than freestanding or libc (ASM0003); two projects of one restore graph with the same PackageId ("Ambiguous project name"); include folders outside the project that don't rebuild; packages without include files; $ORIGIN that /bin/sh empties; a bad AsmToolchain; recommendations (-z defs; -Xvc is now the SDK's own) |
ASMREF000–003 |
missing references; a freestanding Linux executable referencing a shared-only library; a freestanding project referencing libc-only code (NU1201) |
ASMSLN001–003 |
no msbuild-sdks entry; .slnx entries without the type GUID; an SDK version other than the one the checks encode |
On AsmSdk's own samples it reports no error and no warning, and each of AsmSdk's test projects that must fail is reported with the SDK's own error.
inspect_output.py
Summarizes an output of any RID, using the llvm-readobj from the toolchain package, which it
finds in the NuGet cache by itself. It reports:
- ELF (Linux): shared object, PIE or static executable;
SONAME,NEEDED,RUNPATHand the interpreter; the exported and imported symbols, with their types and sizes; whether the stack is executable; - PE (Windows): DLL or program; the exports, which only a
FUNCTIONdirective or theExportsFilegives a DLL; the imported DLLs and functions; ASLR and DEP; - Mach-O (macOS): dylib or program; the install name and needed libraries; the exported and imported symbols, by their C names;
- for a static library of any OS, its members and the symbols each defines.
python inspect_output.py bin/Debug/freestanding/linux-x64/libhello.so
python inspect_output.py bin/Release/libc/win-x64/calc.dll --expect-type dll --expect-export calc_sum --expect-needed ucrtbase.dll
python inspect_output.py bin/Release/libc/osx-arm64/libcalc.dylib --expect-type dylib --expect-export calc_sum
With --expect-… options it exits 1 when an expectation fails, which makes it a release
gate in CI.
How well it works
The plugin ships with an evaluation (claude plugin eval) that runs Claude with and without
it. What Claude wrote in each run was then built with the real SDK, and the outputs were run
on Linux. Results from 2026-11-17, measured with plugin 0.1.0 and AsmSdk 0.1.0 (not re-run
since):
| Measure | With the plugin | Without |
|---|---|---|
| Requests about AsmSdk that loaded the skill (Sonnet 5.5, 30 runs) | 30 / 30 | — |
| Near-miss requests that left it alone (CMake, MASM, C intrinsics, …; 30 runs) | 30 / 30 | — |
| Agent-written projects that built and passed their checks | 12 / 12 | 4 / 12 |
| Mean time per task | 232 s | 444 s |
The full results, including what every run wrote, are in the marketplace's benchmarks.
Plugin 0.3.0's tasks name this SDK version, and one of them ports a Linux-only library to Windows and macOS. Its build check builds every RID a task names, reads the exports of each library (ELF, PE and Mach-O), and runs the Linux outputs. A right answer and wrong ones per task, kept with the suite, prove the graders and the build check before they judge a run.