@skills · Owner

Agent skills by mohitmishra786

169 skills indexed from github.com/mohitmishra786. Reference any of them in AdaL, Claude Code, Cursor or any coding agent — nothing to install.

• abi-and-calling-conventions · Skill · 156 stars

  ABI and calling conventions skill for cross-language boundaries. Use when explaining System V AMD64, ARM AAPCS, RISC-V psABI, stack frames, variadic calls,

• adc-dac-baremetal · Skill · 156 stars

  Bare-metal ADC and DAC skill. Use when configuring analog sampling, DMA-driven ADC, calibration, or DAC output on MCUs. Activates on queries about ADC bare

• af-xdp · Skill · 156 stars

  AF_XDP skill for high-performance XDP sockets. Use when creating AF_XDP sockets, configuring UMEM and XSK rings, XDP_REDIRECT programs, copy vs zero-copy m

• allocators · Collection · 156 stars
• apple-silicon · Skill · 156 stars

  Apple Silicon skill for M-series development and profiling. Use when leveraging unified memory, Metal Performance Shaders, Instruments profiling, sysctl ha

• arm-sve · Skill · 156 stars

  ARM SVE skill for scalable vector extension programming. Use when writing SVE intrinsics, predicate registers, VLA loops with svcnt, auto-vectorization wit

• assembly-arm · Skill · 156 stars

  AArch64 and ARM assembly skill for reading and writing ARM assembly code. Use when reading GCC/Clang output for AArch64 or ARM Thumb targets, writing inlin

• assembly-riscv · Skill · 156 stars

  RISC-V assembly skill for RV32/RV64 programming. Use when working with the RISC-V ISA, calling conventions (psABI), inline assembly with GCC/Clang, underst

• assembly-x86 · Skill · 156 stars

  x86-64 assembly skill for reading, writing, and debugging assembly code. Use when reading GCC/Clang assembly output, writing inline asm in C/C++, understan

• async-io · Collection · 156 stars
• baremetal · Collection · 156 stars
• baremetal-startup · Skill · 156 stars

  Bare-metal startup skill for reset-to-main bring-up. Use when writing startup code, vector tables, .data/.bss init, stack setup, or crt0 for Cortex-M/RISC-

• bazel · Skill · 156 stars

  Bazel build system skill for C/C++ projects. Use when writing BUILD files with cc_library and cc_binary rules, registering toolchains, configuring remote e

• binaries · Collection · 156 stars
• binary-hardening · Skill · 156 stars

  Binary hardening skill for security-hardened C/C++ builds. Use when enabling RELRO, PIE, stack canaries, FORTIFY_SOURCE, CFI sanitizers, shadow stack, or s

• binutils · Skill · 156 stars

  GNU binutils skill for binary manipulation and analysis. Use when using ar for static libraries, strip or objcopy for binary processing, addr2line for conv

• bootloaders-embedded · Skill · 156 stars

  Embedded bootloader skill for firmware update and app handoff. Use when writing a custom bootloader, jumping to application code, relocating VTOR, or imple

• branch-prediction-and-speculation · Skill · 156 stars

  Branch prediction and speculation skill for CPU security and performance. Use when explaining branch predictors, mispredict penalties, speculative executio

• build-acceleration · Skill · 156 stars

  Build acceleration skill for C/C++ projects. Use when reducing compilation times with ccache, sccache, distcc, unity builds, precompiled headers, split DWA

• build-systems · Collection · 156 stars
• bus-drivers-i2c-spi · Skill · 156 stars

  I2C and SPI bus driver skill for Linux client drivers. Use when writing i2c_driver or spi_driver, register access over bus, DMA SPI transfers, or ACPI/DT c

• carbon-lang · Skill · 156 stars

  Carbon language skill for C++ interop and toolchain. Use when evaluating Carbon syntax, bidirectional C++ interop, building carbon-toolchain, or comparing

• cargo-workflows · Skill · 156 stars

  Cargo workflow skill for Rust projects. Use when managing workspaces, feature flags, build scripts, cargo cache, incremental builds, dependency auditing, o

• clang · Skill · 156 stars

  Clang/LLVM compiler skill for C/C++ projects. Use when working with clang or clang++ for diagnostics, sanitizer instrumentation, optimization remarks, stat

• cmake · Skill · 156 stars

  CMake build system skill for C/C++ projects. Use when writing or refactoring CMakeLists.txt, configuring out-of-source builds, selecting generators (Ninja,

• code-generation-and-backends · Skill · 156 stars

  Code generation and backends skill for LLVM targets. Use when explaining instruction selection, DAG legalization, target lowering, or adding backend suppor

• compiler-frontend · Skill · 156 stars

  Compiler frontend skill for lexing, parsing, and type checking. Use when building a lexer/parser, designing AST nodes, implementing symbol tables, type che

• compiler-internals · Collection · 156 stars
• compiler-optimizations-deep · Skill · 156 stars

  Deep compiler optimizations skill for RA, ISel, and PGO. Use when explaining register allocation, instruction selection, LICM, vectorization limits, or pro

• compilers · Collection · 156 stars
• computer-architecture · Collection · 156 stars
• conan-vcpkg · Skill · 156 stars

  C/C++ package manager skill covering Conan and vcpkg. Use when adding third-party library dependencies to C/C++ projects, managing binary compatibility, in

• concurrency-debugging · Skill · 156 stars

  Concurrency debugging skill for diagnosing data races and deadlocks. Use when reading TSan race reports, debugging deadlocks with GDB thread inspection, an

• containers-internals · Skill · 156 stars

  Linux containers internals skill for namespaces, cgroups, and OCI. Use when understanding clone/unshare namespaces, cgroups v2 limits, overlayfs, runc, sec

• core-dumps · Skill · 156 stars

  Core dump analysis skill for production crash triage. Use when loading core files in GDB or LLDB, enabling core dump generation on Linux/macOS, mapping sym

• cpp-coroutines · Skill · 156 stars

  C++20 coroutines skill for understanding coroutine mechanics and debugging. Use when working with co_await, co_yield, co_return, implementing promise_type,

• cpp-modules · Skill · 156 stars

  C++20 modules skill for modern C++ projects. Use when working with named modules, module partitions, header units, CMake MODULE_SOURCES, Clang -fmodules-ts

• cpp-templates · Skill · 156 stars

  C++ template skill for reading template errors and optimizing compile times. Use when deciphering template error stacks, setting -ftemplate-backtrace-limit

• cpu-cache-opt · Skill · 156 stars

  CPU cache optimization skill for C/C++ and Rust. Use when diagnosing cache misses, improving data layout for cache efficiency, using perf stat cache counte

• cpu-pipelines-and-hazards · Skill · 156 stars

  CPU pipeline skill for hazards, forwarding, and stalls. Use when explaining pipeline stages, data/control hazards, forwarding paths, or branch stalls in pe

• cross-gcc · Skill · 156 stars

  Cross-compilation with GCC skill for embedded and multi-architecture targets. Use when setting up cross-gcc toolchains, configuring sysroots, building for

• cuda · Skill · 156 stars

  CUDA C/C++ skill for NVIDIA GPU kernel programming. Use when writing CUDA kernels, managing thread/block/grid hierarchy, optimizing memory access patterns,

• cuda-debugging · Skill · 156 stars

  CUDA debugging skill for GPU program correctness. Use when debugging with cuda-gdb, running NVIDIA Compute Sanitizer memcheck/racecheck, analyzing GPU core

• cuda-profiling · Skill · 156 stars

  CUDA profiling skill for NVIDIA GPU performance analysis. Use when profiling kernels with Nsight Systems or Nsight Compute, interpreting roofline models, d

• custom-allocators · Skill · 156 stars

  Custom allocator skill for memory allocation strategies. Use when implementing pool/slab/arena allocators, tuning jemalloc/mimalloc, writing Rust GlobalAll

• datasheet-and-refmanual-reading · Skill · 156 stars

  Datasheet and reference manual reading skill for embedded engineers. Use when extracting pinouts, electrical limits, register maps, clock trees, or timing

• debug-optimized-builds · Skill · 156 stars

  Debugging optimized builds skill for diagnosing issues in release code. Use when debugging RelWithDebInfo builds, using -Og for debuggable optimization, wo

• debuggers · Collection · 156 stars
• device-drivers · Skill · 156 stars

  Linux device driver skill for kernel driver development. Use when writing platform/i2c/spi drivers, char device lifecycle, IRQ handling, DMA engine API, re

• device-tree · Skill · 156 stars

  Device tree skill for Linux hardware description. Use when writing DTS/DTSI, bindings, overlays, phandles, or debugging OF platform probe failures. Activat

• dma-baremetal · Skill · 156 stars

  Bare-metal DMA skill for memory-peripheral transfers. Use when configuring DMA channels, circular mode, double buffering, or DMA IRQ completion. Activates

• dpdk · Skill · 156 stars

  DPDK skill for userspace packet I/O. Use when initializing EAL, configuring PMD drivers, using mbuf pools and rte_ring, setting up huge pages, RSS, or test

• dwarf-debug-format · Skill · 156 stars

  DWARF debug format skill for understanding debug information. Use when inspecting DWARF sections with dwarfdump, working with split DWARF (.dwo files), set

• dynamic-linking · Skill · 156 stars

  Dynamic linking skill for Linux/ELF shared libraries. Use when debugging library loading failures, configuring RPATH vs RUNPATH, understanding soname versi

• ebpf · Skill · 156 stars

  eBPF skill for Linux observability and networking. Use when writing eBPF programs with libbpf or bpftrace, attaching kprobes/tracepoints/XDP hooks, debuggi

• ebpf-rust · Skill · 156 stars

  Rust eBPF skill using the Aya framework. Use when writing eBPF programs in Rust with aya-bpf and aya-log, defining BPF map types, integrating with tokio us

• elf-inspection · Skill · 156 stars

  ELF binary inspection skill for Linux. Use when examining ELF executables or shared libraries with readelf, objdump, nm, or ldd to understand symbol visibi

• embedded · Collection · 156 stars
• embedded-rust · Skill · 156 stars

  Embedded Rust skill for bare-metal microcontroller development. Use when using probe-rs or cargo-embed for flashing and debugging, setting up defmt logging

• flamegraphs · Skill · 156 stars

  Flamegraph generation and interpretation skill. Use when converting perf, Valgrind Callgrind, or other profiler output into SVG flamegraphs using Brendan G

• freertos · Skill · 156 stars

  FreeRTOS skill for embedded RTOS development. Use when creating tasks, managing priorities, using queues and mutexes, detecting stack overflows, configurin

• fuzzing · Skill · 156 stars

  Fuzzing skill for automated input-driven bug finding in C/C++. Use when setting up libFuzzer or AFL++ fuzz targets, defining fuzz entry points around parsi

• gcc · Skill · 156 stars

  GCC compiler skill for C/C++ projects. Use when selecting optimization levels, warning flags, debug builds, LTO, sanitizer instrumentation, or diagnosing c

• gdb · Skill · 156 stars

  GDB debugger skill for C/C++ programs. Use when starting a GDB session, setting breakpoints, stepping through code, inspecting variables, debugging crashes

• gpio-baremetal · Skill · 156 stars

  Bare-metal GPIO skill for pin configuration and interrupts. Use when configuring GPIO modes, alternate functions, pull resistors, or EXTI interrupts on STM

• gpu · Collection · 156 stars
• gpu-memory-model · Skill · 156 stars

  GPU memory model skill for SIMT execution and memory hierarchy. Use when analyzing warp divergence, memory coalescing, shared memory bank conflicts, cache

• hardware-counters · Skill · 156 stars

  Hardware performance counter skill for low-level CPU analysis. Use when collecting PMU events with perf stat, using the PAPI library, measuring cache miss

• hare-lang · Skill · 156 stars

  Hare language skill for simple systems programming. Use when building with hare build/test/run, Hare stdlib, C FFI with @extern, tagged union error handlin

• heaptrack · Skill · 156 stars

  heaptrack memory profiler skill for Linux. Use when tracking heap allocations, finding memory leaks, measuring peak heap usage, identifying allocation hots

• hip-rocm · Skill · 156 stars

  HIP and ROCm skill for AMD GPU programming. Use when writing HIP kernels with hipcc, porting CUDA code via HIPIFY, profiling with rocprof, debugging with r

• hpc · Collection · 156 stars
• hypervisor-internals · Skill · 156 stars

  Hardware virtualization internals skill for Intel VT-x and AMD-V. Use when studying VMCS/VMCB, EPT/NPT page tables, VMEXIT handling, APIC virtualization, o

• include-what-you-use · Skill · 156 stars

  Include What You Use (IWYU) skill for optimizing C/C++ header includes. Use when reducing compilation cascades, interpreting IWYU reports, applying mapping

• intel-vtune-amd-uprof · Skill · 156 stars

  Intel VTune and AMD uProf profiling skill for microarchitecture analysis. Use when analyzing hotspots, microarchitecture bottlenecks, memory access pattern

• interpreters · Skill · 156 stars

  Bytecode interpreter and JIT compiler skill for implementing language runtimes in C/C++. Use when designing bytecode dispatch loops (switch, computed goto,

• interrupts-and-exceptions-baremetal · Skill · 156 stars

  Bare-metal interrupt and exception skill for Cortex-M NVIC. Use when writing ISRs, configuring priorities, handling HardFault, or measuring interrupt laten

• io-uring · Skill · 156 stars

  io_uring skill for Linux async I/O. Use when building high-performance servers with liburing, multi-shot operations, provided buffers, fixed files, zero-co

• jit-compilation · Skill · 156 stars

  JIT compilation skill for runtime code generation. Use when building LLVM ORC JIT, LLJIT, Cranelift JIT, inline caches, trampolines, or Rust dynasm codegen

• kernel · Collection · 156 stars
• kernel-concurrency · Skill · 156 stars

  Kernel concurrency skill for Linux locking and synchronization. Use when choosing spinlocks vs mutexes, using RCU, seqlocks, completions, or applying memor

• kernel-debugging · Skill · 156 stars

  Linux kernel debugging skill for kgdb, kdb, ftrace, kprobes, and crash analysis. Use when setting up kgdb over serial, using ftrace and trace-cmd, insertin

• kernel-debugging-advanced · Skill · 156 stars

  Advanced kernel debugging skill for ftrace, trace-cmd, perf, kprobes, kgdb, and crash analysis. Use when tracing kernel functions, profiling syscalls in ke

• kernel-dev · Collection · 156 stars
• kernel-internals · Skill · 156 stars

  Linux kernel internals skill for scheduler, memory, and VFS subsystems. Use when analyzing CFS/EEVDF scheduling, buddy/SLUB allocators, page cache, memory

• kernel-memory-management · Skill · 156 stars

  Kernel memory management skill for Linux mm subsystem. Use when using kmalloc, vmalloc, page allocator, SLUB, or debugging OOM and memory zones. Activates

• kernel-security · Skill · 156 stars

  Linux kernel security skill for LSM, hardening, and exploit mitigations. Use when writing SELinux/AppArmor policies, seccomp-bpf filters, configuring KASLR

• kernel-testing · Skill · 156 stars

  Linux kernel testing skill for KUnit, kselftest, syzkaller, and LTP. Use when writing KUnit tests, running kselftest harness, configuring syzkaller fuzzing

• languages · Collection · 156 stars
• linker-scripts · Skill · 156 stars

  Linker script skill for embedded bare-metal targets. Use when writing or modifying GNU ld linker scripts, placing code and data in specific flash or RAM re

• linkers-lto · Skill · 156 stars

  Linker and Link-Time Optimisation (LTO) skill. Use when configuring GNU ld, gold, or lld linker flags, diagnosing link-order issues or undefined symbols at

• linux-kernel-architecture · Skill · 156 stars

  Linux kernel architecture skill for subsystem overview. Use when navigating kernel source, understanding boot flow, initcalls, or major subsystems (VFS, sc

• linux-kernel-modules · Skill · 156 stars

  Linux kernel module skill for writing and debugging loadable kernel modules. Use when writing LKMs with Kbuild, adding module parameters, creating /proc an

• linux-perf · Skill · 156 stars

  Linux perf profiler skill for CPU performance analysis. Use when collecting sampling profiles with perf record, generating perf report, measuring hardware

• lldb · Skill · 156 stars

  LLDB debugger skill for C/C++/Swift/Objective-C programs. Use when debugging with LLDB on macOS, FreeBSD, or Linux-clang environments, mapping GDB mental m

• llvm · Skill · 156 stars

  LLVM IR and pass pipeline skill. Use when working directly with LLVM Intermediate Representation (IR), running opt passes, generating IR with llc, inspecti

• llvm-ir-and-passes · Skill · 156 stars

  LLVM IR and passes skill for reading compiler IR. Use when analyzing LLVM IR, understanding SSA, pass pipeline order, or running opt on bitcode. Activates

• llvm-passes · Skill · 156 stars

  LLVM passes skill for writing compiler optimizations. Use when writing FunctionPass or ModulePass, registering PassPlugins, running with opt, using analysi

• low-level-dev-skills · Collection · 156 stars
• low-level-programming · Collection · 156 stars
• low-power-embedded · Skill · 156 stars

  Low-power embedded skill for sleep modes and energy optimization. Use when configuring MCU sleep/stop/standby, peripheral clock gating, wake-up sources, or

• make · Skill · 156 stars

  GNU Make skill for C/C++ build systems. Use when writing or debugging Makefiles, understanding pattern rules and automatic dependency generation, managing

• memory-hierarchy-and-caches · Skill · 156 stars

  Memory hierarchy skill for caches, coherence, and locality. Use when explaining cache levels, associativity, false sharing, prefetching, or MESI coherence.

• memory-model · Skill · 156 stars

  C++ and Rust memory model skill for concurrent programming. Use when understanding memory ordering, writing lock-free data structures, using std::atomic or

• meson · Skill · 156 stars

  Meson build system skill for C/C++ projects. Use when setting up a Meson project, configuring build options, managing dependencies with the wrap system, cr

• mlir · Skill · 156 stars

  MLIR skill for multi-level intermediate representation. Use when writing custom dialects, defining ops with ODS, writing lowering passes, running mlir-opt,

• mmio-and-bit-manipulation · Skill · 156 stars

  MMIO and register access skill for bare-metal firmware. Use when accessing memory-mapped peripherals with volatile, bit masks, RMW patterns, or endianness

• mpi · Skill · 156 stars

  MPI skill for distributed-memory parallel programming. Use when writing MPI_Send/Recv programs, collective operations, non-blocking communication, MPI+Open

• msvc-cl · Skill · 156 stars

  MSVC cl.exe and clang-cl skill for Windows C/C++ projects. Use when configuring Visual Studio builds, MSBuild, or clang-cl as a drop-in MSVC replacement. C

• ninja · Skill · 156 stars

  Ninja build system skill. Use when diagnosing Ninja build failures, understanding Ninja's role as a low-level build executor generated by CMake or other me

• numa-programming · Skill · 156 stars

  NUMA programming skill for multi-socket memory locality. Use when detecting NUMA topology, binding processes with numactl, using libnuma API, building NUMA

• observability · Collection · 156 stars
• openmp · Skill · 156 stars

  OpenMP skill for shared-memory parallel programming. Use when writing parallel for loops, reductions, task parallelism, SIMD directives, GPU offloading, or

• openocd-jtag · Skill · 156 stars

  OpenOCD skill for embedded hardware debugging. Use when configuring OpenOCD for JTAG or SWD targets, flashing firmware, connecting GDB to bare-metal target

• os-dev-scratch · Skill · 156 stars

  OS development from scratch skill for bootloader through context switching. Use when building a minimal x86-64 OS, setting up GDT/IDT/page tables, writing

• peripherals-from-datasheet · Skill · 156 stars

  Peripheral driver methodology skill from MCU reference manuals. Use when reading register maps, timing diagrams, and writing drivers from vendor documentat

• pgo · Skill · 156 stars

  Profile-guided optimisation skill for C/C++ with GCC and Clang. Use when squeezing maximum runtime performance after standard optimisation plateaus, implem

• platform · Collection · 156 stars
• platform-device-model · Skill · 156 stars

  Platform device model skill for Linux driver binding. Use when implementing platform_driver probe/remove, sysfs attributes, device properties, or deferred

• profilers · Collection · 156 stars
• protocol-analysis · Skill · 156 stars

  Protocol analysis skill for serial bus debugging. Use when decoding I2C/SPI/UART with logic analyzer concepts, sigrok/PulseView, or Python capture scripts.

• qemu · Collection · 156 stars
• qemu-embedded-simulation · Skill · 156 stars

  QEMU embedded simulation skill for bare-metal MCU testing. Use when running ARM/RISC-V firmware in QEMU, selecting machine models, loading -kernel ELF, or

• qemu-for-kernel-development · Skill · 156 stars

  QEMU kernel development skill for driver and kernel testing. Use when booting custom kernels in QEMU, Buildroot/Yocto rootfs, virtio devices, or NFS root f

• qemu-kvm · Skill · 156 stars

  QEMU/KVM skill for virtualization and kernel development. Use when running qemu-system-x86_64 with KVM, configuring virtio devices, VFIO passthrough, QMP m

• rdma-verbs · Skill · 156 stars

  RDMA verbs skill for InfiniBand and RoCE programming. Use when using libibverbs API, creating queue pairs, RDMA read/write operations, or benchmarking with

• resource-optimization-lowend · Skill · 156 stars

  Resource optimization skill for constrained embedded targets. Use when reducing flash/RAM usage, analyzing stack depth, reading linker map files, or tuning

• reverse-engineering · Skill · 156 stars

  Reverse engineering skill for binary analysis. Use when decompiling with Ghidra, analyzing with radare2, scripting RE tools, triaging with strings/file/xxd

• riscv-privileged · Skill · 156 stars

  RISC-V privileged architecture skill for M/S/U modes and traps. Use when handling CSRs, trap handlers, PLIC/CLINT interrupts, OpenSBI integration, page tab

• runtimes · Collection · 156 stars
• rust · Collection · 156 stars
• rust-async-internals · Skill · 156 stars

  Rust async internals skill for understanding and debugging async Rust. Use when understanding the Future trait and poll model, Pin and Unpin, tokio task sc

• rust-build-times · Skill · 156 stars

  Rust build time optimization skill for reducing slow compilation. Use when using cargo-timings to profile builds, configuring sccache for Rust, using the C

• rust-cross · Skill · 156 stars

  Rust cross-compilation skill. Use when building Rust binaries for a different target architecture or OS, using cross or cargo-zigbuild for hermetic cross-c

• rust-debugging · Skill · 156 stars

  Rust debugging skill for systems programming. Use when debugging Rust binaries with GDB or LLDB, enabling Rust pretty-printers, interpreting panics and bac

• rust-ffi · Skill · 156 stars

  Rust FFI skill for C interoperability. Use when calling C libraries from Rust, generating Rust bindings with bindgen, exporting Rust functions to C with cb

• rust-no-std · Skill · 156 stars

  Guide no_std Rust development for embedded and bare-metal targets. Use when writing #![no_std] crates, understanding core vs alloc vs std, implementing cus

• rust-profiling · Skill · 156 stars

  Rust profiling skill for performance analysis. Use when generating flamegraphs from Rust binaries, measuring monomorphization bloat with cargo-llvm-lines,

• rust-sanitizers-miri · Skill · 156 stars

  Rust sanitizers and Miri skill for memory safety validation. Use when running AddressSanitizer or ThreadSanitizer on Rust code, interpreting sanitizer repo

• rust-security · Skill · 156 stars

  Rust security skill for supply chain safety and memory-safe development. Use when auditing dependencies with cargo-audit, enforcing policies with cargo-den

• rust-unsafe · Skill · 156 stars

  Rust unsafe code skill for systems programming. Use when writing or reviewing unsafe Rust, understanding what operations require unsafe, implementing safe

• rustc-basics · Skill · 156 stars

  Rust compiler skill for systems programming. Use when selecting RUSTFLAGS, configuring Cargo profiles, tuning release builds, reading assembly or MIR outpu

• sanitizers · Skill · 156 stars

  Compiler sanitizer skill for runtime bug detection in C/C++. Use when enabling and interpreting AddressSanitizer (ASan), UndefinedBehaviorSanitizer (UBSan)

• security · Collection · 156 stars
• simd-intrinsics · Skill · 156 stars

  SIMD intrinsics skill for x86 (SSE/AVX) and ARM (NEON) vectorization. Use when reading auto-vectorization reports, writing SSE2/AVX2/NEON intrinsics, check

• skills · Collection · 156 stars
• spi-i2c-baremetal · Skill · 156 stars

  Bare-metal SPI and I2C skill for serial peripheral buses. Use when implementing master-mode transfers, register read/write protocols, or debugging bus stal

• static-analysis · Skill · 156 stars

  Static analysis skill for C/C++ codebases. Use when hardening code quality, triaging noisy builds, running clang-tidy, cppcheck, or scan-build, interpretin

• stm32-baremetal · Skill · 156 stars

  STM32 bare-metal skill for CMSIS-only MCU projects. Use when scaffolding STM32 firmware without HAL, configuring clocks/RCC, using CMSIS headers, or buildi

• strace-ltrace · Skill · 156 stars

  strace and ltrace skill for system call and library call tracing. Use when a binary behaves incorrectly without crashing, diagnosing file-not-found errors,

• timers-pwm-baremetal · Skill · 156 stars

  Bare-metal timer and PWM skill. Use when configuring general-purpose timers for PWM, input capture, or periodic ticks without RTOS. Activates on queries ab

• triton-lang · Skill · 156 stars

  Triton language skill for Python GPU kernel authoring. Use when writing Triton kernels with @triton.jit, tl.load/store, masking, atomics, benchmarking with

• uart-serial-baremetal · Skill · 156 stars

  Bare-metal UART skill for serial console and debug. Use when configuring baud rate, polling or IRQ-driven TX/RX, or integrating DMA with UART. Activates on

• valgrind · Skill · 156 stars

  Valgrind profiler skill for memory error detection and cache profiling. Use when running Memcheck to find heap corruption, use-after-free, memory leaks, or

• verilog-basics-for-lowlevel · Skill · 156 stars

  Verilog basics skill for firmware and kernel engineers. Use when reading RTL to understand hardware behavior, reset/clock domains, bus protocols, or collab

• virtual-memory-paging-and-tlb · Skill · 156 stars

  Virtual memory skill for paging, page tables, and TLB. Use when explaining page faults, multi-level page tables, TLB behavior, or virtual vs physical addre

• virtualization · Collection · 156 stars
• wasm-emscripten · Skill · 156 stars

  WebAssembly with Emscripten skill for C/C++ to WASM compilation. Use when compiling C/C++ to WebAssembly with emcc, configuring EXPORTED_FUNCTIONS, underst

• wasm-wasmtime · Skill · 156 stars

  WebAssembly runtime skill using wasmtime. Use when running WASM modules with wasmtime CLI, working with WASI preview2, using the component model, embedding

• writing-char-drivers · Skill · 156 stars

  Character driver skill for Linux kernel char devices. Use when implementing file_operations, cdev, copy_to_user, ioctl, or mmap for userspace interfaces. A

• zephyr · Skill · 156 stars

  Zephyr RTOS skill for embedded development. Use when building Zephyr applications with west, configuring boards and targets, working with Kconfig and devic

• zig · Collection · 156 stars
• zig-build-system · Skill · 156 stars

  Zig build system skill for multi-file Zig projects. Use when writing or debugging build.zig files, adding executables or libraries, integrating C source fi

• zig-cinterop · Skill · 156 stars

  Zig C interoperability skill. Use when calling C from Zig, calling Zig from C, using @cImport and @cInclude, running translate-c on C headers, defining ext

• zig-compiler · Skill · 156 stars

  Zig compiler skill for systems programming. Use when compiling Zig programs, selecting optimization modes, using zig cc as a C compiler, reading Zig error

• zig-comptime · Skill · 156 stars

  Zig comptime skill for compile-time evaluation and metaprogramming. Use when using comptime parameters, comptime types, generics via anytype, comptime refl

• zig-cross · Skill · 156 stars

  Zig cross-compilation skill. Use when cross-compiling Zig programs to different targets, using Zig's built-in cross-compilation for embedded, WASM, Windows

• zig-debugging · Skill · 156 stars

  Zig debugging skill. Use when debugging Zig programs with GDB or LLDB, interpreting Zig runtime panics, using std.debug.print for tracing, configuring debu

• zig-testing · Skill · 156 stars

  Zig testing skill for writing and running tests. Use when using zig build test, writing comptime tests, using test filters, working with test allocators to

Browse the @skills marketplace