sunsided

Commodore 64 BASIC V2: programming rules, the three data types (integer, floating-point, string) and their constants/variables/arrays, expressions, arithmetic/relational/logical operators and precedence, string handling, INPUT/GET, program crunching, and the full alphabetical reference of every BASIC keyword (commands, statements, functions, operators) with abbreviations. Use this skill WHEN reading, writing, or debugging C64 BASIC, or asked things like "what does FOR/NEXT do", "how do I DIM an array", "what's the abbreviation for PRINT", "why do I get ?REDIM'D ARRAY", "operator precedence in BASIC", or "is GET blocking". Pairs with c64-petscii (CHR$/screen codes), c64-keyboard (keys & editor), c64-memory-map (POKE/PEEK targets), and c64-assembly (SYS/USR).

Workflow for reverse-engineering existing Commodore 64 code — .prg/.bin files, cartridge dumps, memory snapshots, and raw 6510 listings. Covers the .prg load address, the tokenized BASIC stub and its SYS launcher, classifying every address as RAM / ROM call / hardware register, recognizing KERNAL ($FFxx) and BASIC ROM entry points, spotting I/O accesses to the VIC/SID/CIA by address, and the common idioms (raster waits, IRQ hooks, self-modifying code). Use this skill WHEN asked to "disassemble this C64 program", "what does this .prg do", "explain this 6510 dump", "find the SYS address", "what is it POKEing $D0xx for", or to trace/annotate a binary. Pairs with c64-assembly, c64-kernal, c64-memory-map, c64-vic-ii, c64-sid, c64-cia.

The two Commodore 64 control (game) ports: reading joysticks, paddles, a light pen, and mouse, and how they map to hardware registers (CIA1 $DC00/$DC01, SID POT $D419/$D41A, VIC light-pen $D013/$D014). Use this skill WHEN a user asks "which port is player 1", "how do I read the joystick", "what bits are up/down/ left/right/fire", "how do I read paddles", "why are paddles unreliable in BASIC", "how does the light pen work", or mentions control port 1/2, $DC00, $DC01, fire button, or POTX/POTY. Pairs with c64-cia, c64-sid, and c64-vic-ii.

C64 screen graphics from the programmer's view: the five VIC-II display modes (standard/multicolor text, ECM, standard/multicolor bitmap), custom 8x8 character sets, screen/color/character memory layout, video bank selection, and smooth scrolling. Use this skill WHEN you see "how do I define custom characters", "turn on multicolor mode", "POKE 53272 / 53265 / 53270 / 53281", "$D011 $D016 $D018 bitmap mode", "switch VIC-II video banks", "where is screen RAM / color RAM", "set the bitmap base", or "smooth scroll the screen". Pairs with c64-sprites, c64-vic-ii (raster timing, full chip spec), and c64-memory-map.

The C64 keyboard and screen editor: every special key and what it does — the Commodore (C=) key, CTRL, RUN/STOP, RESTORE, SHIFT / SHIFT-LOCK, CLR/HOME, INST/DEL, cursor (CRSR) keys, function keys f1–f8, RETURN — plus screen-editor behavior (quote mode, insert mode, full-screen line editing, the 10-key buffer). Use this skill WHEN asked "what does the C= key do", "switch to lower case", "what is RUN/STOP + RESTORE", "clear the screen", "what's quote mode", "type a cursor-down into a string", "reset the C64", or about the f-keys. Pairs with c64-petscii and c64-cia (the NMI/RESTORE mechanism).

The complete Commodore 64 memory map and banking: zero page, stack, the BASIC program area and pointers, screen and color RAM, the $D000-$DFFF I/O area, the BASIC/KERNAL/character ROMs, the $0000/$0001 6510 port plus the 82S100 PLA that switches ROM/RAM/I/O/char-ROM, and VIC bank select via CIA2 $DD00. Use this skill WHEN asking where something lives or how to switch banks: "what's at $D000", "bank out the KERNAL", "C64 memory map", "where is screen/color RAM", "read the character ROM", "what do LORAM/HIRAM/CHAREN do", "which VIC bank am I in", "zero-page usage". Pairs with c64-assembly, c64-vic-ii, c64-sid, c64-cia, and c64-kernal.

Commodore 64 hardware sprites (MOBs, movable object blocks): the 24x21-pixel / 63-byte sprite shape, sprite pointers, enabling sprites, X/Y positioning including the X MSB ($D010) for positions past 255, sprite color, multicolor sprites, 2x X/Y expansion, sprite-to-background and sprite-to-sprite priority, and collision detection. Use this skill WHEN you see questions like "how do I make a sprite on the C64", "POKE 53269 enable sprite", "move a sprite past x 255 / $D010 MSB", "$D000 $D015 $D017 $D01C $D01D sprite registers", "set sprite pointer 2040", "multicolor sprite", "expand a sprite", "detect sprite collision $D01E $D01F", or "sprite priority". Pairs with c64-graphics (screen/charset/bank setup) and c64-vic-ii (exact raster timing and chip behavior).

The physical Commodore 64 and its servicing: system specs, the chip complement (6510, VIC-II, SID, two CIAs, PLA, ROMs, DRAM) and each chip's role, the circuit theory (power, reset, clock, video/audio, ports), board revisions and how to ID them, connector pinouts, and troubleshooting. Use this skill WHEN a question is about C64 hardware, a board, or repair — "what chip is U17", "why won't my C64 boot", "blank screen on power-up", "power-brick voltage", "which board revision", "5-pin vs 8-pin video", "expansion port pinout", "PLA failure". Pairs with c64-memory-map, c64-vic-ii / c64-sid / c64-cia, and c64-io / c64-game-ports.

Use when setting up asset loading, designing asset handles/registries, building offline asset processing tools, implementing hot reload, loading spritesheets or atlases, or deciding how to organize game asset directories.

Use when adding or modifying audio playback, sound mixing, music systems, or real-time audio synthesis in a Rust game. Trigger when user mentions rodio, cpal, sound effects, music playback, audio mixer, or procedural audio.

Use ONLY when the project already uses Bevy (bevy in Cargo.toml) or the user explicitly asks about Bevy. Do not trigger for custom wgpu/winit/ECS projects. Use when working with Bevy plugins, components, systems, states, the Bevy asset server, schedules, or events.

Use when adding egui debug overlays, frame timing panels, entity inspectors, renderer stat displays, in-game feature toggles, or puffin profiler integration to a Rust game. Also use when the user asks how to add a debug view or troubleshoot via in-game tooling.

Use when designing ECS component layouts, system ordering, event systems, deferred spawning/despawning, fixed vs variable update schedules, or deciding how game world data flows to the renderer. Use for both custom ECS and library ECS (hecs, legion).

Use ONLY when the project uses Godot with Rust (gdext or gdnative in Cargo.toml, or .gdextension file present). Do not trigger for pure Rust/wgpu projects. Use when working with GodotClass,

Use when setting up input handling, designing action maps, rebindable controls, gamepad support, mouse delta handling, input buffering, or deciding how raw winit events should flow to gameplay code.

Use when preparing a Rust game for distribution, setting up release builds, bundling assets, creating Linux/Windows/macOS packages, or configuring asset path resolution for deployed executables.

How to read and write 6502/65C02/65816 assembly source for the Merlin macro assembler (Merlin 8, Merlin Pro, Merlin 16/16+, Merlin 32 on Apple II/IIgs, and Merlin 64/128 on Commodore). Covers Merlin's source column layout, its pseudo-opcodes/directives (ORG, EQU, DFB, DW, DDB, DCI, ASC, HEX, DS, LUP, DO/FIN, MAC/EOM), the macro system and parameters (]1..]8), label and variable conventions (:local, ]var), expression operators and Merlin's left-to-right evaluation, the low/high/bank byte-select operators, and forced addressing. Use this skill WHENEVER you encounter, write, or port Merlin-format assembly source, see Merlin directives like DFB/DCI/LUP/MAC/EOM/PUT, see labels like ]LOOP or :SKIP, or need to understand a .S Merlin listing. Especially trigger when the user mentions Merlin, or asks why an assembler expression evaluates oddly (left-to-right!), or how a macro expands. Pairs with the 6502-instruction-set, 6502-memory-map, and 6502-to-rust skills.

Reference and semantics for the MOS 6502 / 65C02 / 65816 instruction set: mnemonics, addressing modes, opcode bytes, cycle counts, and exact flag effects. Use this skill WHENEVER you read, write, disassemble, trace, explain, or port 6502-family assembly (including Apple II, Commodore, NES, Atari, BBC Micro code), or when you need to know what an instruction does to the registers, status flags, or memory. Trigger on questions like "what does this 6502 routine do", "what flags does ADC set", "is this a 65C02 instruction", "trace this assembly", or any opcode/mnemonic (LDA, STA, JSR, ROL, BIT, SWEET16 excepted) appearing in a file. Pairs with the 6502-merlin-assembler, 6502-memory-map, and 6502-to-rust skills.

Memory maps, I/O register layouts, ROM entry points, and zero-page conventions for the main 6502 home computers: the Apple II family, the Commodore 64, and the Atari 400/800/XL/XE. Covers Apple II soft switches ($C000-$C0FF), language card, Monitor ROM and Applesoft FP; C64 6510 $00/$01 banking, VIC-II/SID/CIA and the KERNAL table ($FFD2 CHROUT); and Atari ANTIC/GTIA/POKEY chips, shadow registers, CIO/SIO and the $E450 OS vectors. Use this skill WHENEVER you need to know what a memory address or hardware register means on an Apple II, C64, or Atari, what a soft switch or ROM routine does, where the screen/zero page/stack are, or how banking works. Trigger on addresses like $C050, $FDED, $D020, $FFD2, $D40A, $E456, on names like COUT/CHROUT/CIOV/POKEY/FAC, or any "what is at address X" / "what does this poke/STA do to hardware" question. Pairs with the 6502-instruction-set, 6502-merlin-assembler, 6502-sweet16, and 6502-to-rust skills.

Reference for SWEET16, Steve Wozniak's 16-bit interpreted pseudo-processor built into the Apple II Integer BASIC ROM (entry $F689). SWEET16 is a tiny virtual machine with sixteen 16-bit registers (R0-R15) living in zero page, invoked by JSR SWEET16 followed by inline bytecode and terminated by RTN. Use this skill WHENEVER you see a JSR $F689 (or JSR SWEET16) followed by data bytes, encounter SWEET16 mnemonics (SET, LDD, STD, POP, STP, CPR, BNC, RTN, BS/RS), need to disassemble or trace SWEET16 bytecode, or are porting Apple II code that drops into SWEET16 for compact 16-bit pointer math and block moves. Trigger on "what is SWEET16", "$F689", inline bytecode after a JSR, or 16-bit register ops like "SET R1" / "LDD @R1". Pairs with the 6502-instruction-set, 6502-memory-map, and 6502-to-rust skills.

A workflow for porting 6502/65C02/65816 assembly (Apple II, Commodore 64, Atari 8-bit, NES, Merlin source, SWEET16) to modern Rust by first lifting it to an explicit intermediate language (IL) and then raising that IL to idiomatic Rust. Covers the two-stage method (faithful flag-explicit lift → idiom recovery → emit), modeling A/X/Y/flags/memory, translating carry/overflow/BCD correctly, recognizing idioms (16-bit math, multiply, pointer loops, jump tables), and mapping ROM/hardware calls. Use this skill WHENEVER the user wants to port, translate, convert, reimplement, decompile, or "rewrite in Rust/a modern language" any 6502-family assembly or disassembly, or asks how a 6502 routine would look in Rust, or how to build an intermediate representation of 6502 code. Trigger on "port this assembly to Rust", "convert this 6502 routine", "reimplement this Apple II code". Pairs with the 6502-instruction-set, 6502-merlin-assembler, 6502-memory-map, and 6502-sweet16 skills.

Use whenever the user wants to open a pull request, draft a PR description, or says anything like "open a PR", "write a PR description", "create a pull request", "draft the PR body", or "/pr". Analyzes the diff between the current branch and its base, detects the repository's PR template if present, and produces a reviewer-oriented title plus body that explains *what the change does and why*—not a commit-by-commit log. Includes review instructions that guide a human through the change in the order they should read it. Defaults to emitting the text for the user to paste; offers to invoke `gh pr create` if the user wants. Trigger on any phrasing that involves describing or opening a PR, even if the user doesn't say "skill".

Use whenever the user wants to commit changes, split a working tree into commits, write a commit message, or says anything like "commit this", "make commits for these changes", "write a commit message", or "/commit". Detects the repository's commit style (Conventional Commits, plain imperative, etc.), groups unstaged + staged changes into semantically-coherent commits, writes a concise subject plus an extended body covering rationale, before→after, findings, and issue links, then stages and commits each group after confirming the plan with the user. Trigger even when the user does not explicitly say "skill"—any request to commit, stage, or describe local changes counts.

Use when the user wants to author Taskfile content: creating new Taskfiles, adding new tasks, writing task dependencies/preconditions/variables, or restructuring tasks across files. The user might say "add a [name] task", "set up tasks for", "create a Taskfile", "where should this task go", "convert my Makefile", or simply describe task names and commands they want automated - even without saying "Taskfile" explicitly. Covers all ecosystems (cargo, yarn, wasm-pack, dotnet, cmake) and all scenarios: single projects, monorepos with nested includes, gitignored local overrides vs. shared dist files. Skip for: explaining how existing tasks work, debugging task run failures, or general go-task concept questions.

Taskfile discovery and execution — use before running any project command when the project may use go-task. Invoke when the user asks: "run the tests", "build the project", "start the dev server", "run lint/fmt/bench/ci/clean", "what task should I run for X", "task [name] is failing", "how do I pass args to task", or when a Taskfile.yaml/Taskfile.dist.yaml is present. Always read the Taskfile before guessing ecosystem commands — prevents npm-vs-yarn mistakes, wrong test wrappers (cargo test vs nextest), and missed env vars or dep chains. Covers task field inspection, nested includes, CLI_ARGS passthrough, and manual fallback when task is unavailable. Use taskfile-authoring when creating or updating Taskfiles.

Use when understanding or changing code in this repo: locating where a symbol is defined, what calls it, how a request flows across the API boundary, or the blast radius of a change (which symbols, tests, endpoints — and which other indexed repos — a change affects). Prefer this over ls/grep sweeps.

Use when reading, parsing, writing, dumping, or debugging any Jill of the Jungle data file (DMA, SHA, JN, MAC, CFG, VCL, CMF/DDT, Crunched Screen Image) or when reasoning about its byte layout, flag bits, object iTypes, savegame structure, palette handling, or per-file quirks. Examples: "why is this DMA entry parsing wrong?", "add a SHA tile dumper", "what's the layout of the JN object record?", "is the player object always first?", "decode dan.cmf", "parse the VCL sound table", "port the Crunched Screen Image renderer".