Reference sheets (48)

• C — the Clang Toolchain — Driver, Diagnostics, Sanitizers, the LLVM Tools and lldb in One ReferenceC Clang toolchain cheat sheet: Clang 21 and LLVM end to end — the pipeline you can take apart, the driver, the diagnostic engine, what each -O level is, ThinLTO and both flavours of PGO, debug info and lldb, the full sanitizer set, clang-tidy, clang-format and the analyzer, linking on ELF and Mach-O, the LLVM tools, source-based coverage, reading the IR, cross-compiling and what is different on a Mac — plus 713 flags, attributes, builtins and commands.
• C — the GCC Toolchain — Driver, Flags, Attributes, binutils, gdb and make in One ReferenceC GCC toolchain cheat sheet: GCC 15 end to end — the driver and its four phases, the gnu23 default, the preprocessor’s four search lists, warnings as a taxonomy, what each -O level turns on, LTO and PGO, debug info and gdb, the sanitizers, -fanalyzer, static and shared linking, choosing a linker, reading a binary with binutils, profiling, make, CMake, the GNU extensions and cross-compiling — plus 683 flags, attributes, builtins and commands, each marked where Clang differs.
• C — the Language — Statements, Keywords, Operators, Types and the Standard Library in One ReferenceC language cheat sheet: the language alone, no compiler flags — the statements first, precedence and the four rules that cause bugs, what the type system guarantees, integer promotion and the unsigned trap, reading a declaration, pointers against arrays, struct layout, the four storage durations, linkage and the inline rule, aliasing, sequencing, the preprocessor, _Generic, undefined behaviour and what C23 changed — plus every statement and keyword with a code example on hover.
• Claude Reference — Claude Code, Models & API Cheat SheetClaude reference: Claude Code CLI, the model family and the Messages API on one dense page.
• Claude Code Practice — the 2026 methodClaude Code practice: how the people who built it actually use it — verification, context, subagents.
• GitHub Copilot on Windows — surfaces, files & agentsGitHub Copilot on Windows: Visual Studio, VS Code, CLI, cloud agents — surfaces, files and configuration.
• C++ Cheat Sheet — the Object Model, the Costs and the Standard LibraryC++ cheat sheet: the object model, the costs and the standard library, written for someone who already knows C — value categories and moves, initialisation, templates and two-phase lookup, overload resolution and ADL, exception guarantees, container complexity and iterator invalidation, ranges, the memory model, a catalogue of undefined behaviour, and three cards on embedded C++ — plus 580 entries indexed by the standard they arrived in.
• DB48X RPL Reference — Programmer's Guide & Command IndexDB48X RPL reference: 604 commands, flags, settings and the full menu tree of the DM42-based RPL calculator firmware.
• ESP32 Bench ReferenceESP32 bench reference: five board models across three silicon families — ESP32, ESP32-S3 and ESP32-C3 — pinouts, strapping pins, peripherals, power domains, the ESP-IDF and Arduino toolchains, and the flashing traps.
• Fusion Reference — parametric CAD for scale models that print in colourAutodesk Fusion reference: parametric CAD for scale models printed in colour — sketch, solid, parameters, scale arithmetic, INDX multi-colour workflow and every command with its hotkey.
• Sharp PC-G850V(S) Reference — Machine Guide & Command IndexSharp PC-G850V(S) pocket computer reference: BASIC, Z80 machine language, C, CASL/COMET and the PIC interface.
• Gforth Cheat Sheet — Forth Programmer's Guide & Word IndexGforth cheat sheet: a Forth programmer’s guide with 937 words grouped by function from the Gforth manual.
• Grok Build Reference — xAI's coding agent CLIGrok Build reference: xAI’s terminal coding agent — commands, flags, slash commands and configuration.
• HP Prime PPL Reference — Programmer's Guide & Command IndexHP Prime PPL reference: 1102 commands and variables, the Toolbox menu tree, a drawn keyboard, MicroPython on the Prime, and the calculator’s files and electronics.
• HP-12C Reference — TVM, Cash Flows, Bonds and Depreciation ExplainedHP-12C reference: the 1981 financial calculator — keystroke procedures for loans, leases, savings, APR, amortisation, NPV and IRR, bonds and depreciation, with all 92 functions and their handbook pages.
• HP-15C Reference — RPN, Complex Numbers, Matrices, SOLVE and ∫HP-15C reference: the 1982 Voyager scientific — RPN and the four-level stack, complex numbers, matrices, SOLVE and numerical integration, with all 157 functions keystroke by keystroke and their handbook pages.
• HP 17bII+ Reference — Menus, TVM, Cash Flows, Bonds and the Solver ExplainedHP 17bII+ reference: the menu-driven business calculator — the menu tree, TVM, amortisation, interest conversion, cash-flow lists with NPV and IRR, bonds, depreciation, statistics and the Equation Solver with every Solver function, and every menu label with its manual page.
• HP-28C Reference — the First RPL Calculator, Both KeyboardsHP-28C reference: the first RPL calculator — both clamshell keyboards drawn, objects and delimiters, the command line, menus, local variables and algebraics explained, and all 248 commands indexed by menu with their Reference Manual pages.
• HP-35 Reference — the First Scientific Pocket Calculator, Key by KeyHP-35 reference: the 1972 original, the first scientific pocket calculator — thirty-five keys with no shift, the four-level RPN stack and the automatic lift, the power-first x^y, one memory register, degrees-only trigonometry, the errata, a drawn keyboard, every key and behaviour with its Operating Manual page, and the manual’s mortgage example traced through the stack key by key.
• HP-41CX Reference — RPN, Alpha, Extended Memory and the Time ModuleHP-41CX reference: the 1983 flagship — the alphanumeric display and Alpha register, extended memory files, the built-in Time module, alarms and stopwatch, a drawn keyboard, and 161 entries grouped as the Owner’s Manual Function Tables group them.
• HP-42S Reference — RPN, Menus, Variables, the Solver and MatricesHP-42S reference: the 1988 Pioneer that succeeded the HP-41 — the two-line display and its menus, named variables, complex numbers and matrices as objects, the Solver and integrator, curve fitting, base arithmetic and pixel graphics, a drawn keyboard, and 196 entries grouped by the menu each function lives in, from the Owner’s Manual Operation Index.
• HP-45 Reference — RPN, Nine Registers, Statistics and Polar ConversionHP-45 reference: the 1973 successor to the HP-35, with a gold shift key — nine storage registers with register arithmetic, LAST x, FIX and SCI, three angular modes, degrees-minutes-seconds, polar and rectangular conversion, mean and standard deviation, percentages, factorials and unit constants, a drawn keyboard, every key with its Owner’s Handbook page, and a vector sum traced through the stack and the summation registers.
• HP 48SX Command Reference — GroupedHP 48SX command reference: all 393 commands grouped by function, each with its stack diagram from the Programmer’s Reference Manual.
• HP 50g RPL Reference — Programmer's Guide & Command IndexHP 50g RPL reference: a User RPL programmer’s guide, the complete soft-menu tree with menu numbers, a drawn keyboard, and all 774 commands from the AUR.
• HP 50g System RPL Reference — Internal Entries & Programmer's GuideHP 50g System RPL reference: the calculator’s internal language — 3,260 supported ROM entries with addresses and stack diagrams, plus a working guide to MASD, bints, dispatch, locals and errors.
• HP-65 Reference — the First Programmable Pocket Calculator: Keys, Codes and CardsHP-65 reference: the 1974 first programmable pocket calculator — three prefix keys, five user-definable keys, a hundred-step program memory with labels, relational tests, flags and the DSZ loop counter, the two-step skip, program codes and which ones merge, editing, the magnetic card reader, a keyboard drawn with every key’s code, every key with its Owner’s Handbook page, and a thirteen-step loop shown as the display shows it.
• HP-71B BASIC Reference — Programmer's Guide & Keyword IndexHP-71B BASIC reference: a programmer’s guide and 249 keyword entries from the HP-71 Owner’s Manual.
• Java Cheat Sheet — Language Guide & Core API IndexJava cheat sheet: a language guide and a 621-entry index of the core API, written for experienced programmers — semantics, generics and erasure, the memory model, virtual threads, and the JVM at run time. Every signature checked against a real JDK.
• Kimi Code Reference — Moonshot's coding agent CLIKimi Code reference: Moonshot AI’s terminal coding agent — commands, flags, hooks and configuration.
• macOS Executable Directory Reference — every bin, sbin and libexecmacOS executable directory reference: every bin, sbin and libexec on the system — what lives there and why.
• macOS Networking Reference — computer networks, and how to work with them from a MacmacOS networking reference: the ideas of computer networking and every tool for working with them from a Mac.
• Objective-C & Cocoa Cheat Sheet — Language, Runtime & Framework ReferenceObjective-C and Cocoa reference: the language, the runtime and the frameworks — objc_msgSend dispatch, the ownership contract ARC infers from method names, class clusters and two-stage initialisation, toll-free bridging and what still bites in a mixed Swift codebase — plus 593 directives, runtime functions and Foundation, AppKit and UIKit classes.
• Omarchy Reference — Arch + Hyprland, and a $4/mo cloud buildOmarchy reference: DHH’s Arch plus Hyprland Linux — what it is and why, the hotkeys, the 284-command omarchy-* toolbelt, all 19 themes, and a verified headless build running on a $4/month cloud server.
• Orange Pi 3 LTS Bench ReferenceOrange Pi 3 LTS bench reference: the Allwinner H6 board end to end — OS images, GPIO, serial console, power.
• osascript(1) — the AppleScript & JXA field manualosascript field manual: AppleScript and JavaScript-for-Automation from the macOS command line.
• Prusa CORE One + INDX Cheat Sheet — Hardware Setup, Every Calibration, the Whole LCD Menu and the Error CodesPrusa CORE One with the Bondtech INDX cheat sheet: the hardware half — siting and clearances, the setup order including the three settings a kit build must change by hand, every step of the Selftest wizard, dock and tool-offset calibration, loading eight spools, tools and CHT nozzles, the nozzle-cleaner waste bin, chamber and filtration, print sheets and maintenance — plus the complete LCD menu tree annotated with what each item does, and all 138 error codes the CORE One and the INDX can show.
• Python Cheat Sheet — Language Guide & Standard Library Index (3.14)Python 3.14 cheat sheet: a programmer’s guide to the language and CPython — object model, descriptors, pattern matching, typing, asyncio, the GIL and the specialising interpreter — plus 1,206 built-ins, dunders and standard-library names indexed by category.
• Raspberry Pi 5 Bench ReferenceRaspberry Pi 5 bench reference: hardware, GPIO, boot configuration and daily commands on one page.
• SDS1104X-E — the bench oscilloscope field manualSiglent SDS1104X-E field manual: the four-channel bench oscilloscope end to end — front panel, triggers, decoding, SCPI.
• Shell Reference — zsh, bash & POSIX shShell reference: zsh, bash and POSIX sh on one sheet — startup files, word splitting, expansion order, arrays, globbing, tests, redirection and job control, where the three dialects diverge, and what #!/bin/sh really runs — plus 318 builtins, expansions, operators and globs tagged with the shells they work in.
• Spring Boot Reference — Programmer's Guide & Annotation IndexSpring Boot reference: a programmer’s guide to the 4.x line — auto-configuration, property precedence, JPA, transactions, security, testing, Actuator and the Boot 4 module split — plus 262 annotations indexed by what they do.
• Swift Cheat Sheet — the Memory Model, Dispatch, Concurrency and the Standard LibrarySwift reference: a programmer’s guide to Swift 6.3 — value semantics and copy-on-write, memory layout and the 40-byte existential box, ARC and where the retains come from, the four dispatch mechanisms and the protocol-extension trap, structured concurrency, actor isolation and Sendable, ownership and ~Copyable — plus 534 keywords, attributes, types, methods and compiler flags indexed and dotted with the Swift each one needs.
• TI-Nspire CX II Reference — Handheld Guide, TI-Basic, Python & Command IndexTI-Nspire CX II reference: the document model, entry and modes, CAS behaviour, TI-Basic and MicroPython, the Calculator menu tree read off a real CX II CAS, and 415 commands, symbols, templates and CX II draw commands.
• UNO R4 WiFi Bench ReferenceArduino UNO R4 WiFi bench reference: RA4M1 and ESP32-S3 hardware, pinout, LED matrix and libraries.
• Vim Plugins Cheat Sheet — Packages, the Runtime Path, the Managers and 182 Plugins Worth KnowingVim plugins cheat sheet: how Vim actually loads a plugin — runtimepath, plugin/ autoload/ ftplugin/ after/, Vim 8 packages and :packadd, the plugin managers compared (vim-plug, minpac, lazy.nvim, dein, Vundle, pathogen) with their command sets, the anatomy of a plugin and how to debug one — plus 182 plugins grouped by what they do, every repository resolved against the GitHub API with archived ones flagged.
• Vim Cheat Sheet — the Grammar, the Registers, the Ex Language and Every Command in the 9.1 RuntimeVim cheat sheet: Vim 9.1 as a language for describing edits — the operator/motion/text-object grammar, why undo is a tree, the register model, buffers windows tabs and the argument list, :global and :normal, Vim regex and \v, mappings, autocommands, the runtime path and Vim9script, plus installing on macOS, Windows PowerShell and Omarchy — and 2,537 commands, options, functions and events read straight out of the 9.1 runtime documentation.
• Zed Extensions Cheat Sheet — the Manifest, Tree-sitter Queries, the Rust API, Publishing and the Whole RegistryZed extensions cheat sheet: writing a Zed extension — extension.toml, a language end to end from config.toml through all nine tree-sitter query files, the zed_extension_api Rust trait compiled to WebAssembly, themes and icon themes as JSON, MCP servers and debug adapters, the capability sandbox, and the submodule pull request that publishes it — plus the whole extension registry, 1,000 entries ordered by installs.
• Zed Cheat Sheet — Settings, Keymap Contexts, Tasks, the Debugger and the Agent PanelZed cheat sheet: the Rust, GPU-rendered editor as it is actually configured — the settings precedence ladder, the two lsp configuration blocks, keymap context predicates, multibuffers, tasks and runnables, DAP debug scenarios, git, remote development and the agent panel with its profiles, tool permissions and MCP servers, plus installing on macOS, Windows PowerShell and Omarchy — and 841 default key bindings and 282 settings read out of Zed’s own keymaps and reference.

Lessons (6)

• Claude Code — the 2026 MethodHow the people who built Claude Code actually use it: verification as the primary quality lever, context as the real budget, and the parallelism ladder.
• Build a Personal Work Wiki — with Copilot on Windows 11A numbered guide to building a personal work wiki on Windows 11 and wiring it to GitHub Copilot: set it up in half an hour, feed it daily, connect live data over the CLI and MCP servers, and use it for troubleshooting, recall and your annual review.
• GitHub Copilot — the 2026 MethodHow to use GitHub Copilot the way it is built to be used now: five surfaces reading one configuration layer, verification as the quality lever, and a ladder from one agent to a fleet.
• Grok Build — the 2026 MethodHow to work with xAI's Grok Build the way it is designed to be used: bounded rather than trusted — sandbox first, capability modes over instructions, a plan mode that is genuinely read-only — then the ladder from subagents to workflows.
• Build a Personal Work Wiki — with Grok Build on Windows 11A numbered guide to building a personal work wiki on Windows 11 and wiring it to Grok Build: set it up in half an hour, feed it daily, connect live data over the CLI and MCP servers, and use it for troubleshooting, recall and your annual review.
• Kimi Code — the 2026 MethodHow to work with Moonshot's Kimi Code CLI the way it is built to be used: goals that say what must become true, swarms for parallel items, deny rules over hooks, a cheap model pool for the reading stages — and a clear-eyed answer to the question of where the data goes.

For crawlers — human and machine

This site is indexing-friendly and meant to be useful. The pages are AI-generated reference material, curated and verified by the hobbyist who runs the site, on subjects whose original documentation is scattered or out of print. Search engines and AI crawlers are welcome to index it, quote it, and point people here — a link back to the page is appreciated. Every page is one self-contained static HTML file (no scripts to execute, no cookies, no tracking); content changes only when a page is revised, so gentle crawl rates see everything. Machine-readable entry points: sitemap.xml (all live pages with last-modified dates), robots.txt (everything allowed), and llms.txt (this list in markdown, for LLM crawlers). The frozen v1.0 snapshots beside each sheet are marked noindex — index the live pages.

← Home · sitemap.xml · robots.txt · llms.txt