Web64 IDE Changelog

This file records notable user-facing Web64 IDE changes. Dates use the ISO YYYY-MM-DD format. Work that has not yet been included in a numbered release remains under Unreleased.

Unreleased

2.5.3 - 2026-09-28

Added

• Managed Cartridge Resources revision 3 now demonstrates the same logical ROM read from both C and live native assembly, including web64/cartridge.inc call macros and the generated resource include. The standalone project is also in web64-examples and indexed in the Examples collection. Added a dedicated Native Cartridge Runtime manual with the full C/ASM API, four-profile authoring workflow, status and memory contracts.
• Native managed cartridge resources for Standard 8K, Standard 16K, Magic Desk and EasyFlash. Cartridge Layouts now binds a resident target, logical project-file/target-output resources, directory RAM and explicit writable transfer regions. Native mastering deterministically splits resources into extents, finalizes a fixed-width directory and exposes generated C/ASM IDs, 32-bit sizes and source-to-CRT provenance. The guest C/ASM API reads/copies across physical boundaries and restores cartridge mapping through resident code. Wrapped resident PRG booting now covers all four profiles, with an EasyFlash RAM trampoline and explicit bank-0 ROML payload placement. Existing layouts and the Native Cartridge Starter retain their prior behavior.
• Managed cartridges reject direct F5 PRG start for the bound resident target; Run Cartridge boots the real mastered CRT. The user manual documents resource access, RAM ownership and interrupt limits.
• Added Managed Cartridge Resources, a compact v3 template with one authoritative C project and four saved cartridge layouts. Catalog revision 11 contains 36 stock templates and 215 advertised selections.
• Portable v3 templates can keep typed conditions, switches, bounded loops and native table/matrix generation in authored C/ASM with // @web64template comments. The template dialog previews resolved source and downloads a standalone native project. Scripted Template Starter revision 3 demonstrates this with one saved source project across 64 buildable selections. Catalog revision is 10.
• The six buffered World templates now let project creators use their editable map color plane as PAL Color RAM output, alongside the existing full-height region-color mode. The bidirectional World scroller now accepts diagonal joystick chords for smooth movement in all eight directions. The map-color examples use a smaller, bounded playfield so color publication fits the frame.
• Added Animated Sprite Overlay and Double-buffered XOR 3D v3 templates. The cube defaults to bitmap.inc runtime lines, with a direct ASM option; both consume native generated matrices and maintain independent XOR histories for their two bitmap buffers.
• Reworked the graphical starters into a moonlit oak courtyard with composed ruins and native editable terrain. Players have four distinct animated frames, and multicolor World projects use matching multicolor sprites. Expanded ASM and C programs link clear of I/O, display buffers and their stacks.
• Project tree Manage now offers native project-copy import/download through the browser file-input/download paths alongside normal handle-based Open/Save.

• Reauthored the 25 legacy stock templates as portable v3 projects and added seven focused starters for bitmap graphics, trajectory motion, actor batching, raster text, persistent game data, text applications, and debugger/profiler workflows. The Native Cartridge Starter remains unchanged. Graphical starters now ship editable forest-ruin art rather than stick figures and placeholder patterns.
• The W64SID Music + SFX starter now includes a real one-shot voice-3 tracker overlay triggered by joystick Fire. Port 1/2 choices bind to the actual CIA input, and the running audio project identifies itself on screen.
• Added a reproducible v3 packaging pipeline and release matrix that resolve and build all 214 finite stock selections. The matrix distinguishes 203 target-byte groups from 211 runtime groups, so shared cartridge PRG bytes do not conceal different media layouts. Catalog revision is 9.

Fixed

• Portable template source validation accepts cartridge/generated.inc for a managed resident target, matching its existing acceptance of the generated C header. Unrelated missing virtual includes still fail validation.
• Managed Cartridge Resources template revision 2 now initializes VIC text mode and Color RAM on cartridge cold boot. The previous example reached its C loop and read the ROM palette but left the display blank because cartridge autostart precedes KERNAL screen setup.
• Web64-C static ABI now defines and claims the 32-bit comparison scratch used by long expressions, including generated cartridge resource sizes.
• Restored // line comments in Web64 native assembly, including inline instruction and include comments. Quoted slashes remain literal, and the editor now highlights both // and ; comments.
• World Static Map initializes the shared colors from its courtyard palette and draws all 25 visible rows, including Color RAM, instead of inheriting BASIC colors and leaving three stale rows.
• Template source dependency validation now recognizes Web64's bundled c64lib assembly includes while continuing to reject missing virtual project includes.

2.5.2 - 2026-09-26

Added

• Native VIC-synchronized Step Frame advances the complete C64 to the next real frame transition and pauses at the first safe CPU instruction boundary. The Debugger adds a compact Frame control and Ctrl+F9 shortcut, with native epoch/raster stop details and breakpoint precedence.
• The user manual now includes a debugger expression operator reference, conditional breakpoint examples, safe-read limits, and the distinction between a raster-register condition and native Step Frame.

• Debugger v3 fills the available workspace with a taller resizable Memory pane, full-height Execution/Variables scrolling, pinned Memory browsing and an explicit Follow PC control.
• F9 Step, F10 Step Over, Ctrl+F10 Run to Cursor and Shift+F9 Continue/Pause operate while the emulator stays visible. A stopped presentation request displays the latest completed VICE frame without advancing the guest or inventing new pixels.
• Native debugger ABI 5 adds stop-bound, checked edits for C64 registers and proven CPU-visible ordinary RAM. Proven direct-PRG C scalars, static struct scalar members, compatible one-level struct pointer members, and eligible watched lvalues use the same mutation path; unsafe or unproven locations remain read-only.
• Emulator Options and Settings now offer a compact five-position speed slider (1x, 2x, 4x, 8x, 16x). It uses VICE's paced CPU-speed resource, defaults to 1x, and persists in .web64proj independently of the uncapped Warp toggle.

Fixed

• Native Step now pauses at the monitor's reached instruction boundary, so one Step executes exactly one instruction, including consecutive multi-byte instructions. Checkpoint step-past uses the same corrected boundary count.
• Read-only debugger refreshes preserve the same stopped identity, so a draft register or memory edit is not rejected merely because another panel observed the paused machine.
• Successful debugger edits, including unchanged-value writes, invalidate stale stopped observations. Executable-byte edits clear dependent source instruction/breakpoint evidence instead of retaining misleading provenance.
• When the emulator display has focus, F5 reaches the C64 instead of triggering the IDE Run shortcut. F5-based IDE shortcuts remain available when focus is elsewhere.

2.5.1 - 2026-09-25

Added

• Coherent stopped CPU observations now serve Memory, Variables and passive Watches. The compact Variables pane can save raw CPU-memory and expression watches, plus typed integer scalar watches when launched direct-PRG storage and mapping are proven. No memory-access watchpoints are implied.
• Breakpoint intents can carry bounded v1 execution conditions for registers, flags, safe CPU-visible reads and pinned numeric labels. Native ABI 4 evaluates each owner independently before a checkpoint stop; invalid, stale or unsupported conditions stay unarmed. The Execution header reports accepted owners and keeps event address separate from paused PC.
• Portable .web64proj debugger intent persistence retains breakpoint targets/conditions and watch choices without runtime values or handles. Web64 2.5.1 is the minimum release for lossless resave of this optional section.
• The Debugger now shows live 6510 instructions at the paused PC, with a separate checkpoint cause, CPU mapping, loaded-component/source match, and instruction details. Generated ASM is available by default and can browse/follow components pinned to a Run Disk or direct PRG launch without recompiling when the editor selection changes. Run to Cursor uses a temporary guarded checkpoint.
• Native debugger checkpoint guards bind source breakpoints to built instruction bytes and supported C64 mappings. A native instruction-boundary step and checkpoint step-past preserve breakpoints in tight loops, including instructions that return to the same PC. Unsupported source contexts remain pending rather than becoming unconditional address breakpoints.
• Target builds retain compact instruction/source provenance through the ordinary worker transport, including contribution and known package relationships used by multi-load disk debugging.
• The IDE status bar now shows live drive 8 and 9 LEDs with track positions during disk activity. Emulator Options and Settings include a saved, default-off Drive sounds toggle using VICE's motor and head audio emulation.
• Build Targets can consume other targets' payload bytes, raw PRGs, or final packaged artifacts through generated project-VFS paths. Dependency builds follow the graph in producer-first order; missing targets, cycles, path conflicts, and failed producers block consumers. Producer source and settings changes invalidate consumer artifacts.
• Kick-compatible LoadBinary(path) reads exact project-VFS bytes at compile time through bounded .size and .getData(index) access. This supports source-authored checksum and encryption stages without external scripts.
• The Build Targets editor exposes generated output bindings, and the native build manifest schema and public authoring documentation describe their persisted contract.

Fixed

• Paused Source navigation now centers the highlighted instruction when Source is exposed from Generated ASM or opened from the Inspector. Inspector instruction actions are compact, underlined links instead of large buttons.
• Memory Go/Refresh now honors the entered address independently of the paused PC. Stop-token checks reject late or mapping-changed reads, and changed-byte highlighting clears across incompatible stops. Automatic C locals without proven machine-code lifetime show unavailable rather than stale storage; the old low-level condition option no longer silently installs an unconditional breakpoint.
• The Debugger workbench uses a compact command strip and 21-pixel disassembly rows, with registers, breakpoints, and globals/locals beside Execution and Memory below. Current PC, selection, checkpoint cause, source navigation, and breakpoint actions remain distinct.
• Importing a complete .web64proj now keeps every Build Target's declared assembly dialect. The loose-source Kick import review no longer changes an authored native target such as Elite FIREBIRD.
• A stored .byte packager row no longer obscures a unique matching executable instruction in the runtime debugger. The PAL Elite game's ELTA source now remains navigable when its encrypted disk artifact has overlapping data rows.
• Removed the duplicate Line Breakpoints and default Line Map lists from the debugger workflow; the full virtualized source map remains available through Advanced source mapping.
• Disk/Media now reports errors for the selected disk set instead of mixing in unbuilt outputs and layout errors from unrelated disks. Build Dependencies and Run Disk can prepare one release while another release variant remains unbuilt; selecting the other set still shows its own diagnostics.
• Drive 9 is now visible in Emulator Options → Storage, with its on/off state shown in the options summary. This makes it practical to disable the second drive before Run Disk for Elite and other fastloaders that require drive 8 alone; the existing project setting remains saved with .web64proj.
• Disk/Media and Run Disk freshness checks now include producer targets when evaluating generated inputs, so a successfully built dependency graph can be mastered and a changed producer rebuilds its consumers.
• Run Disk builds only the selected disk set's dependency closure. Explicit IDE target builds have a 30-minute whole-build and two-minute per-assembler deadline for large source graphs; bridge jobs keep their existing five-minute maximum.

2.5.0 - 2026-09-23

Native cartridge mastering joins the existing PRG and disk workflows.

Fixed

• Docker-free Cloud API deployment prebundles the shared native template validator, avoiding an oversized raw compiler dependency upload without relaxing template validation or changing authentication.

Added

• Native Standard 8K, Standard 16K, Magic Desk and EasyFlash CRT mastering from current Build Targets and project assets. Saved layouts, bank/window placement maps, dependency-aware builds and blocking layout diagnostics keep the release image inspectable and reproducible.
• Run Cartridge in Disk/Media, the main toolbar and Ctrl+Alt+F5 uses native cartridge attachment and real cold boot. Explicit eject and PRG/disk transitions preserve media ownership. Native C/ASM bank-select, read and bounded copy services are available without c64lib cartridge dependencies.
• Bank-aware source and Generated ASM attribution in the opt-in profiler verifies the running ROM profile, bank, window and captured bytes. Uncertain flash state remains explicitly unbound. The normal non-profiling core is unchanged by this profiling correction.
• Scriptable Native Cartridge Starter with ASM/C + ASM, PAL/NTSC and all four cartridge profiles: 16 real configurations, profile-specific boot targets, editable sources and documented RAM ownership. Native Magic Desk + Disk demonstrates a separate banked path alongside its retained disk loader. Stock templates remain bundled and account-free; legacy Magic Desk projects remain supported.
• Bounded resident-PRG wrapping and disk-to-cartridge review distinguish eligible native migration from unsupported opaque D64 conversion. Mutable files stay on data disks; arbitrary binary conversion and save-to-flash are not advertised.

• ASM selections now show static cycle totals/ranges and emitted byte size in the Inspector, including code/data breakdown and conditional timing notes. Source and Generated ASM reuse the current assembly snapshot without extra builds or emulator/profiler overhead; stale results and unsupported timing are explicit.

• Portable template format v3 can generate native ASM/C tables and matrices from typed template answers using the IDE's existing generator. Bounded generate nodes reuse native presets, numeric formats, overflow rules and output limits; v1/v2 templates remain supported. Includes public schemas, MCP inspection support and authoring documentation. No bridge connection is required for template creation.

Changed

• Disk/Media now separates Disk Mastering and Cartridge Layouts internally. Compact layout settings and individually collapsible placement cards use a responsive one-to-four-column grid, neutral headers and top-right removal controls. No drag reordering or mastering-contract change.
• Restored compact V2 toolbar sizing and restrained gradients in the main, Character, Block and Map toolbars. Sprite Editor Zoom/Grid/Onion controls align with the existing compact buttons. Emulator Options retain accessible controls in a compact responsive layout.

2.4.6 - 2026-09-21

Added

• Official Examples collection in the existing New Project browser: searchable repository metadata, authoritative read-only README rendering, optional tutorial links (including Aurora), and native .web64proj opening as explicitly unsaved independent working copies. No account, template quota, automatic install or Cloud/local persistence is involved.
• Small deterministic examples catalog and maintainer validation. Legacy native defaults reuse the project codec; invalid assets/references remain blocked before workspace replacement and are flagged in discovery rather than silently repaired.

Fixed

• Native project validation accepts generated trajectory binaries with their documented metadata, while checking segment data, counts and runtime option bits. Valid trajectory examples no longer fail the Examples browser's opening gate.
• SID Tracker saves canonicalize untouched legacy cell defaults and refresh compiler-owned effect descriptions/limits, so saving a legacy song no longer leaves it incompatible with strict native project opening.

2.4.5 - 2026-09-20

Changed

• Redesigned Build Targets with compact target navigation, grouped configuration panels and a sticky operational summary. Responsive layouts retain every target option, translation-unit linkage rule, compatibility module and artifact report.
• Neutral V2 styling improves input selection, module descriptions, build defines and empty artifact states without changing compilation or validation behavior.

2.4.4 - 2026-09-19

Added

• Portable .web64template files with a published schema/authoring guide, bounded setup inputs and embedded PNG previews. All 24 bundled templates and 47 configurations retain their native project contents and remain account-free.
• Unified Stock / My Templates browser. External file imports install into the user's Cloud library: Free Cloud supports 5 templates, paid Cloud 20, subject to storage quotas. No browser-local installation or marketplace implementation. Requires the accompanying Cloud API update and quota migration.
• Optional MCP template inspection uses the same browser-native validator. Bridge v0.1.3 supports staged portable files for inspection; external installation stays user-driven through Cloud, while stock creation remains available.
• Optional MCP emulator approval enables current-program Run, pause/reset, emulator-only PNG capture and bounded keyboard/joystick/frame operations. Existing read/edit/build grants remain non-executing. Run requires both build and runtime approval; no Wasm change.
• MCP can use the existing IDE table/matrix generator for validated, paginated native C/ASM source. No arbitrary formula execution or second asset-generation path. Requires bridge v0.1.2 and this browser update.

Fixed

• Emulator PNG capture refreshes the retained WebGL texture on demand so captures do not encode a discarded black drawing buffer. Normal frame rendering and Wasm are unchanged.
• Native assembler reports a blocking error when a resolved .fill count is negative, including binary assets that overrun a target-* padding boundary. Zero-length fills and valid forward-reference layouts remain supported.

2.4.3 - 2026-09-13

Improved

• Native asset authoring guidance connects displayed game maps to their charset/blockset dependencies and recommends independently editable maps for independent levels, rather than using map assets as arbitrary data containers. Valid raw-storage uses remain supported.
• Web64-C documentation explains the 6502 cost model, hot versus setup work, existing arithmetic optimizations, incremental rendering and clean initialization. Generated ASM and profiler guidance are linked for actual measurement.
• Optional MCP knowledge discovery now links schemas, SDK entries and templates to static authoring profiles. Existing tools, native schemas, validation and security boundaries are unchanged; the bridge remains v0.1.0.
• Joystick SDK comments and knowledge results make active-low input explicit, including a canonical pressed-button example. Regenerated manuals and knowledge indexes retain versioned, hash-identified content.

2.4.2 - 2026-09-13

This release introduces cycle/raster profiling for understanding where frame time goes, alongside small workflow improvements.

Added

• Opt-in Cycle / Raster Profiler: bounded native aggregate/detailed captures, model-derived raster and horizontal-cycle views, observed CPU/stall accounting, instruction hotspots, compiler-function costs, inferred call/IRQ regions, named PC ranges, fetched-ASM inspection and build-bound Source/Generated ASM navigation.
• Separate normal and profiling C64 Wasms built from one source with ENABLE_PROFILER. Normal use omits the new CPU/VIC/memory hooks and does not fetch the profiling runtime. Explicit switching restarts one emulator worker, warns about guest RAM/media loss, and preserves the IDE project and editor.
• Immutable, bounded local W64P capture export/import, explicit incomplete/overflow/stale results, verified copied/decompressed-code mappings and address-only fallback when source identity is unavailable. The user manual explains accounting, memory ownership, restart behavior and capture limits.
• Cycle Lab, a small IDE-authored native assembly project for exploring raster IRQ work, display stalls and waiting-loop costs.
• Unsaved-project leave confirmation when closing, reloading or navigating away from the IDE. Protects source, native asset, build-target and disk-layout edits, including pending editor input; dirty projects remain fully buildable and runnable without saving.
• Optional support for the separately installed local MCP bridge v0.1.0, with explicit browser permission for project editing and builds. Ordinary IDE use stays unchanged; Cloud and emulator execution remain user-controlled. Setup is documented in the README and user manual.

The normal emulator runtime remains the default; profiling requires an explicit runtime switch. Native cartridge mastering remains outside this release.

2.4.1 - 2026-09-07

This patch records the compiler correctness, size-generation and application I/O improvements verified during the productivity-application campaign. It retains the v2.4.0 hardware-loader and multi-load workflow; the example's own capacity and feature limits are documented with its project, not presented as platform guarantees.

Added

• A prominent Open Web64 IDE link in the base emulator header, described as a C compiler, assembler and build system. The link remains visible on narrow screens and supports normal keyboard navigation.
• Imported D64 data disks can be mounted on device 8 or 9 without restarting the running C64. Capture Drive downloads that device's current writable image without changing imported project bytes, and Disk/Media links to the existing formatted empty-disk download.
• Mixed-case petscii_mixed and screencode_mixed C string-literal modes for the C64 lower/uppercase character set. Fixed UI labels can be encoded at compile time while live keyboard and file data retain their native PETSCII representation.
• Separate KERNAL operation-error queries for the C and disk SDK families, including carry-set errors whose accumulator byte is zero. READST and drive DOS status remain distinct; cleanup no longer hides an earlier primary failure.

Fixed

• A failed browser file-handle write aborts the pending replacement instead of closing and potentially publishing partial contents; write or close failure never reports a successful save.
• The IDE status bar shows Building with an amber activity indicator during target builds. Long status messages truncate with an ellipsis and retain their full tooltip without pushing project statistics out of the footer; reduced-motion preferences are respected.
• Web64-C correctly preserves header-declared aggregate types, byte-width signed fields, nested expression/call values and control-flow truthiness in modular C90 programs. Native regression gates cover both supported ABIs, exact-width storage and stack integrity.
• C string literals passed to functions retain their exact encoded bytes, including values above $7f, and adjacent literal fragments compose without changing numeric-escape boundaries. Explicit byte escapes remain literal bytes rather than being recoded as text.
• Controlled do { ... } while (0) macros now parse as complete statements under if, else and loop bodies, retaining nearest-else binding, local declarations and single argument evaluation.
• C source mappings retain original file and line ownership through nested includes, preprocessing and modular declarations. Generated helper bodies have their own synthetic provenance instead of borrowing the last user source location.
• Wide C return values preserve their hidden-result storage through nested calls, assignment destinations, narrowing and discarded results; zero-argument calls still pass the required hidden pointer.
• Supported 32-bit struct-member assignments and constant initializers store their complete width, including indirect targets and volatile-source widening. Unsupported wide-member expressions now produce a blocking diagnostic instead of silently truncating data.
• C functions returning a pointer to const data are recognized in definitions and included prototypes. Calls retain pointee size, signedness and const qualification; unsupported return qualifiers and implicit const loss produce located errors rather than missing functions or unsafe writes.
• Pasting into the emulator preserves literal backslashes and normalizes CRLF to one C64 Return. Clipboard text can no longer accidentally become a VICE keyboard escape; the existing programmatic escaped-input path used by Run Disk remains compatible, and embedders can explicitly request literal paste.
• Runtime resource setters reject native failures without replacing the last accepted cached value. MPS-803 runtime packaging includes its required existing ROM and palette; this does not introduce a printer-management UI or claim support for untested printer models.
• Emulator boot applies only native boot-safe SID settings before startup, then waits for resource registration before applying machine, video and drive settings. PAL/NTSC boot aliases are translated to native resource values; Run Disk no longer fails on a premature MachineVideoStandard write.
• Capture Drive detects the optional native disk-flush export before calling it. Builds without that export use the existing detach/read/reattach path instead of failing inside Emscripten; captured data includes true-drive writes.
• Native printer output retains write, flush and close failures, and a failed graphics-output open no longer crashes the emulator. The KERNAL-trap path exposes late sink errors through READST and supports a subsequent healthy job. Virtual IEC still has a limitation: close-only host errors can leave guest READST zero, and recovery after a bus transfer failure needs bus reinitialization. Channel CLOSE is not page eject; no browser capture/download workflow is added.
• The native web build refreshes the configured C64/VSID archive dependencies before linking, preventing changed native sources from being omitted from an apparently successful build. This does not enable unconfigured emulator targets or replace clean builds when native header/configuration changes require them.
• Generated standalone compiler mirrors include the full native-assembler, Kick, sprite, trajectory and GoatTracker module dependencies. Clean-directory import/build tests prevent an incomplete mirror from breaking runtime integration tools.

Improved

• Size-profile C generation shares profitable, compiler-owned frame and argument-stack sequences, retaining ABI, zero-page and source-mapping contracts. The documented extra call cycles apply only to size optimization; speed/debug profiles and explicitly cycle-constrained code are excluded.
• Size-profile stack-frame accesses omit Y/register-status preservation only when control-flow analysis proves it unused. The bounded transformation reduces bytes and cycles without new helpers, memory or ABI changes, and preserves volatile accesses and source/Generated ASM mapping.
• C90 fixed-storage word comparisons, truth tests, returns and eligible argument snapshots avoid redundant temporaries while preserving volatile access, narrowing and side-effect ordering.
• Eligible fixed-address byte compound updates use direct indexed addressing instead of rebuilding a pointer in scratch memory. Index evaluation, byte truncation, address wrapping and the single volatile read/write contract are preserved.

2.4.0 - 2026-09-07

Web64 2.4.0 introduces the public hardware-loader SDK and a fully native multi-load authoring workflow. The 2.3.0 compiler/runtime campaigns and 2.3.1 IDE/SID/Cloud history remain recorded in their original releases below.

Added

• Build Output beside Source and Generated ASM: recent multi-target build reports, live compilation, per-target outcomes and sizes, severity/target filters, message search, source navigation and a copyable tagged log. Reports retain no executable buffers or debugger maps and do not replace normal live compilation.
• Hardware Loader + Disk Mastering template: editable resident ASM and raw/packed bank targets, native D64 placement, IRQ-driven loading feedback and explicit retry/reinstallation. The 24-template catalog was reviewed for current source paths, native targets and creation options; sprite high-X handling, PAL frame waits and published performance metadata were corrected.
• A self-contained public Cyber-Mole project package, accompanying source/assets and IDE-only readmes. Maintainer generators, evidence and immutable checkpoints are preserved outside the public example directory; no private Web64 checkout or Node workflow is required to edit, build or master the game.
• Generic hardware-loader runtime for C and direct ASM: synchronous raw staging, transactional whole-file raw/packed installation, standalone unpack, compact error codes, IRQ-safe abort request, explicit shutdown and post-SAVE reinitialization. Caller memory, clock, IRQ/SID presentation and caching remain application-owned; no game-specific policy or fake asynchronous API is embedded.
• The IDE and runtime share W64X v1's authoritative P39/M255 format. Every selected stream is bounded-decoded and CRC-checked in disjoint scratch before any live destination write, including malformed streams with a recomputed container checksum. Registered zero-page ownership and optional caller-placed SDK images cover banked C/ASM applications without duplicating runtime code.
• Exact-link loader modules, both C ABI fixtures, native target/edit/reopen/D64 coverage, an independent 6502 corruption corpus and PAL/NTSC true 1541-II integration tests. Supported hardware and the interrupt limits of KERNAL SAVE/reinstallation are explicit; unsupported IEC devices and unrestricted Exomizer streams are not claimed.
• A standalone Hardware Loader manual, C/ASM argument-window reference, memory/lifecycle troubleshooting, disk-mastering guide integration and preserved third-party notices. Source checkout commands test:loader-runtime, test:loader-runtime:live and test:loader-runtime:profile reproduce independent verification and cost measurements.

• Browser-native Packed data build targets: validated W64X v1 Exomizer P39/M255 containers, whole-bank or independent fixed-size blocks, explicit staging/capacity controls, saved project settings and asynchronous compile-worker mastering. Native assets remain editable; packed PRGs are data rather than executable/SYS programs.
• Build-target freshness now follows recursive native includes and binary assets, so a map, charset or Tracker save rebuilds affected packed banks and caches before disk mastering. Dynamic/Kick dependency expressions conservatively retain project-wide invalidation.

Fixed

• Run Disk boots the selected filename with the exact mastered PETSCII bytes instead of translating uppercase letters into graphics. The main toolbar and Disk/Media share a Ctrl+F5 action that reveals Code/the emulator, flushes pending edits and builds missing/modified targets before booting; current outputs are reused and build failures block launch. The selected disk set survives tab changes. F5 and Shift+F5 retain PRG run and pause/resume.
• Code-view tabs remain side-by-side at narrow editor widths, with vertically centered, equal-height assembler/SDK badges and emulator toggle. Diagnostic actions use compact, bold underlined text links with a disclosure arrow; project-tree file/folder rows remain flat, with a gradient reserved for WEB64-PROJECT.
• Diagnostic presentation consistently distinguishes yellow [WARN], red [ERROR] and neutral [INFO] in the Inspector, source tooltips, build/media panels and asset/import tools. Warnings remain non-blocking. Disk diagnostics aggregate repeated root causes into actionable summaries with expandable details; missing target outputs offer Build Dependencies and count files separately from distinct targets.
• Removed unconditional, obsolete D64/Exomizer capability warnings from every project. Native browser mastering and compression are reflected in capability metadata. Project-level diagnostics without a valid source location no longer create a false marker on line 1; actual source diagnostics retain their precise navigation.
• SDK-provided implementation images only affect exact linkage when an application actually includes them; merely having read-only SDK virtual files in an IDE project no longer suppresses required native runtime bodies. Legacy C aggregate sizeof now resolves named descriptor types correctly, matching the stack ABI and public native record layouts.

• Disk/Media now exposes each logical PRG's Runnable (SYS) / Raw data mode and downloads the exact mastered logical file. Multi-load music, graphics and level banks can be created entirely inside the IDE, without editing hidden project fields. Stale or unplaced file downloads are blocked.
• The user manual and SID Tracker guide now explain browser-native disk mastering, multi-load memory ownership, SID payload targets, rebuilding/remounting and troubleshooting without depending on an example project or external repository.
• Disk mastering now preserves raw target payloads when SYS-loader injection is disabled, including after compile-worker transport. Multi-loaded data banks retain their original load address instead of receiving an executable relocation wrapper; normal boot targets remain runnable.
• GoatTracker songs now show independent pattern selectors for the three voice columns, initialized from each voice's subtune order. The editor no longer presents one single-voice part as three identical voices; edits, clipboard operations and undo target the displayed voice/pattern, and Patterns Play auditions the displayed combination. Turning Follow off now preserves manual pattern browsing. Existing editable assets need no reimport; full-song player output and accepted SID synthesis/timing remain unchanged.

2.3.1 - 2026-09-05

Web64 IDE 2.3.1 completes the IDE UX, SID Tracker and private SID Cloud library campaign. GoatTracker playback is locked following user comparison with GoatTracker's own exporter; correctness takes precedence over resemblance to the older deployed preview. Cloud deployment and destination testing remain separate rollout steps.

Added

• Character grid multi-selection with anchored Shift ranges, Ctrl toggles, keyboard extension, ordered multi-copy/cut/paste, and undoable append from another compatible project charset. Append preserves existing Block/Map indices; cut blanks bitmap records without deleting slots or metadata.
• Sprite project-bank append with selected-frame copying, stable destination IDs, complete animation/tile remapping, capacity checks and undo. Overlay pairs append atomically; multicolor-to-overlay joins create an empty hires layer, while incompatible hires/overlay directions are rejected.
• Optional SID Tracker Cloud libraries for Instruments, Patterns and Subtunes, with private versioned dependency closures, allocation previews, explicit local-copy imports, rename/delete and atomic undo. Server-side Free quotas are 10/10/10 and Paid quotas 200/100/50; owner isolation, shared storage limits and concurrent saves are enforced by the new Supabase migration and authenticated API.

Fixed

• GoatTracker import now separates editable pattern identity from repeated/transposed order occurrences, retains independent voices/subtunes and nonempty unused patterns, and omits only unreferenced blank slots. Legacy pulse/gate conversion, repeat/restart semantics, instrument inheritance and edited effect/table export are corrected.
• GoatTracker playback now follows its own tick, gate/hard-restart, wave/pulse/filter/speed-table, pitch, vibrato, tempo and funk semantics through the shared Web64 player. SID arithmetic uses RAM shadows instead of write-only hardware reads; signed delta decoding preserves its sign. Runtime PWM steps preserve phase across musical loops, and repeated frames share a compact dictionary.
• Note-entry audition now executes the complete instrument and tables through the same compiled player as song/instrument preview. Preview honors the asset's SID model, PAL/NTSC and half/multispeed CIA timing; malformed tables and unrepresentable exports produce diagnostics instead of silent substitutions.
• Corrected GoatTracker SID register-write order, including envelope-before-gate restoration for normal hard restart and the alternate $F000+ order. Compiled song and audition checks now cover ordered hardware writes as well as per-tick register values; GoatTracker's pitch-table overflow behavior is preserved rather than changed to resemble the older native-dialect preview.
• SID model and clock edits now update the actual playback profile and export metadata in one undoable transaction, instead of changing labels only. The toolbar exposes the concrete preview chip; missing profile fields inherit metadata defaults, and SNG import explains that chip model is not stored in the source. Existing explicit playback choices remain unchanged on load.
• Restored adjacent-row C/E/G instrument-preview timing. Full-table audition no longer inserts three blank rows between phrase notes; single-note audition retains its longer modulation hold. Browser verification counts real SID player calls separately from video presentation and checks audio delivery counters.
• SID song, pattern, instrument and note previews now exclude project Live Patch from the shared C64. Preview startup cancels queued patches and waits for in-flight writes, preventing project code from overwriting the preview driver/IRQ wrapper or suspending its audio. Starting the project explicitly restores normal live patching.
• Imported Cloud subtunes retain their initial per-voice instrument and resolved speed, so relocation into an existing song cannot substitute its instrument zero during pre-roll or inherited notes.
• Generated ASM centers the paused PC on activation and follows subsequent execution when Follow PC is enabled. Manual wheel/touch/navigation scrolling disables follow without removing the current-line highlight.

Upgrade notes

• Reload the updated IDE and save/recompile editable SID assets to regenerate their players. Re-import an original SNG if an older import lost pattern/order structure; existing exported binaries are not updated automatically. Compare the same SID model, clock and engine when checking sound. Verified table modulation and hard-restart behavior are retained; no smoothing was added to imitate the older preview.
• The SID Cloud library requires the parent repository's 202609050001_web64_sid_library.sql migration and updated web64-cloud-api function before the new frontend is used against that environment. Local database/Auth/API checks pass; hosted Edge, ownership/quota and import smoke tests remain for deployment. The source checkout's contributors/ide-sid-cloud-campaign-2026-09-05.md contains the maintainer rollout checklist.

The prior Web64-C compiler and native runtime campaigns remain documented separately in the 2.3.0 section below. This patch does not refresh the manually maintained Mirror Pulse demo disk.

2.3.0 - 2026-09-05

Web64 IDE 2.3.0 delivers both optimization campaigns completed in this session: the Web64-C compiler campaign and the native runtime optimization campaign. Existing public C/ASM contracts and example content remain compatible; the release also corrects compiler semantic defects, tall material-map addressing, and isolated runtime linkage.

Added

• Added a live Warp mode switch to the standalone emulator's Program panel beside Run PRG and Load PRG. The accessible control uses the existing VICE warp API and follows live runtime frame state, including warp changes made outside the switch.

Changed

• Compiler campaign: added width-proven byte extraction from wider right shifts, A-preserving direct byte memory operands, exact-range conditional branch shortening, and sole fastcall argument placement without redundant stack snapshots. Volatile accesses, signedness, evaluation order, source provenance, ordinary calling conventions and exact runtime dependencies remain guarded.
• Compiler campaign measurements: the representative static actor-byte-update kernel falls from 10,768 to 7,914 executed cycles; the narrow-shift kernel falls from 186 to 73. Pinned Egg Hunt/stack builds shrink by 235 bytes and Greedy Ghost/static by 610 bytes. Both supported ABIs and all five optimization profiles receive executable campaign coverage, with deterministic size/speed gates; these kernel and build measurements are not whole-game frame-rate claims.
• Runtime campaign: optimized memory fills/copies/moves with indexed page kernels, bitmap row addressing with constant-time arithmetic, animation record addressing and player-pointer reuse, AABB mask filtering, direct sprite cache addressing, and the fused actor pair loop. Existing C/static, C/stack, direct assembly, argument-window, scratch, and public-state contracts remain unchanged; no new API or mandatory shared table is introduced.
• Runtime campaign measurements, using the completed compiler as the baseline: representative 1,000-byte memory-operation runtime cycles fall by 66–71%, the bottom-right hires plot by 70%, and an ordinary animation transition by 46–47%. The canonical fused actor workload now takes 14,908/14,914 direct-label cycles, retaining the frozen equivalent-oracle headroom gate and all public outputs. C marshalling, ASM window preparation, linked code/data and the small slot-0/row-1 cycle tradeoffs are documented separately.
• Runtime example integration: the unchanged Ascender game rebuilds 121 bytes smaller, with a sampled maximum update/render cost of 17,933 cycles instead of 18,615. Real VICE verification presents all 180 sampled PAL frames without a dropped page flip, while canonical screen/sprite output and native charset bytes remain identical. Mirror Pulse rendering fixtures shrink by 59 bytes in both ABIs and retain exact pixels, course behavior, XOR redraw and palette invariants; its separately maintained URL-loading demo disk is not refreshed by this release.

Fixed

• Compiler campaign: corrected residual bits in non-byte-aligned long shifts and long-to-word scalar/member conversion; volatile narrowing retains complete ordered source reads. Negative global byte initializers now emit valid bytes, and C90 aggregate parsing preserves unsigned long members.
• Compiler campaign: fixed indexed stack-frame address carry and arithmetic flag preservation across frame lowering. Conservative loop-narrowing checks now include nested conditions, loop headers, selectors and parenthesized sizeof/escape observations. Permanent executable regressions cover the previously incorrect results under both ABIs.
• Runtime campaign: corrected full 16-bit material-map row addressing: row 256 no longer aliases row 0. Bounded shift/add addressing also handles padded 16-bit row strides without an index-count loop.
• Runtime campaign: corrected legacy runtime parameter definitions so isolated memory calls exact-link their own data instead of pulling unrelated parameter windows and an incidental memory-fill routine.
• Release documentation: confined narrow-screen manual styles to screen media so they cannot re-enable browser navigation or clip the contents when printing. Strict PDF generation now checks these print-layout conditions before exporting the current manual.

2.2.1 - 2026-09-02

Web64 IDE 2.2.1 is an urgent compatibility patch for the published Mirror Pulse example and its D64 mastering workflow.

Fixed

• Fixed the machine-generated Mirror Pulse project declaring courses.h as a Build Target input even though headers are include-only project files rather than C or assembly translation units. IDE-created targets already restrict this list to .c, .asm, and .s; the corrected example target now builds from main.c, resolves the generated mirror-pulse.prg, and masters it through the target-output path into a valid D64 image.
• Resynchronized the source snapshot embedded in mirror-pulse.web64proj with the standalone optimized main.c, so opening the published project cannot restore an older game implementation.
• Published the reproducibly mastered mirror-pulse.d64 as a required root production artifact, allowing the complete game to launch directly through Web64's ?file= URL without importing the example project.

2.2.0 - 2026-08-29

Web64 IDE 2.2.0 adds the selectively linked Bitmap Drawing Runtime, native assembly helpers across every runtime family, and verified bitmap and trajectory examples. It also adds contextual 6502 opcode reference and editor-wrapping workflows while tightening exact-link discovery and repairing map-overview and continuous-trajectory behavior.

Added

• Added a contextual MOS 6502 opcode quick reference to the Code Inspector. Placing the caret on any official instruction mnemonic shows its expanded name, affected flags, every supported addressing-mode syntax, hexadecimal encoding, byte length, base timing, and page-crossing or taken-branch timing notes. The reference follows both CodeMirror and legacy-editor selections while rejecting mnemonic-like text in C sources, comments, strings, labels, and operands.
• Extended the Code Inspector with contextual argument help for every argument-bearing macro in the generated bundled Web64 runtime includes. Placing the caret on a runtime macro invocation or any of its arguments shows the authoritative invocation signature, owning .inc file, ordered argument list, and current argument position; nested expression commas are ignored and comments, strings, definitions, operands, and non-assembly documents remain excluded. The catalog is derived from the generated .macro declarations so new runtime helpers appear without a second handwritten signature table.
• Added the selectively linked Bitmap Drawing Runtime for hires and multicolor logical pixels, with checked and fast dots, horizontal/vertical/general lines, rectangles, filled rectangles, circles, ellipses, and caller-bounded non-recursive span flood fill. Flood fill v1 is deliberately replace-only: connectivity is defined by the seed's original logical index, palette RAM remains caller-owned, and workspace exhaustion deterministically restores every changed span. Independent two-ABI gates cover exact output, clipping and validation, XOR symmetry, rollback, palette invariance, a sub-frame maximum hires diagonal, and separate small, fragmented, corridor, large-open, and near-full-screen flood benchmarks.
• Added the standalone bitmap-wireframe-3d example. Web64's Matrix generator emits two 32-step row-major Q8.8 rotation-matrix tables; WASD changes pitch and yaw, eight perspective-projected cube vertices feed twelve optimized bitmap lines, and XOR redraw removes the previous orientation without clearing the complete bitmap. Its two-ABI verifier checks generated-matrix provenance, keyboard mapping, projected coordinates, exact wireframe pixels without trails, palette invariance, and setup-plus-line exact closure.

• Added registry-generated native assembly helpers for every Web64 runtime family. Self-contained web64/<family>.inc files expose standard web64_rt_prepare_* and web64_rt_call_* macros, accept emitted C labels for caller-owned structures and buffers, retain call-only helpers for parameterless entries, expand byte-identically to handwritten named-window calls, and link zero runtime bytes while unused.

• Added a standalone trajectory-patterns-asm companion example whose C entry runs only once and whose native hot loop uses the public _web64_rt batch window, caller-owned trajectory buffers, and direct VIC-II projection. Its 600-frame two-ABI gate measures the complete eight-sprite workload—including public event writes and changed-coordinate projection—at 3,783 cycles / 19.246% PAL or less, with every sprite moving continuously and exact-linkage limited to the scalar and batch trajectory modules.
• Added generated web64/trajectory.inc assembly helpers for complete checked/fast calls, setup-only reusable _web64_rt windows, immediate argument placement, packed segment/pattern emission, caller-owned state/event storage, and public Q12.4 position copying. The macros expand to the same instructions/data as handwritten assembly, link nothing while unused, and are now demonstrated by the optimized assembly example without changing its measured hot interval.

Changed

• Reworked flood-fill span discovery, painting, and rollback around aligned C64 bitmap bytes. Hires uses $00/$ff repeated patterns and eight logical pixels per byte; multicolor uses $00/$55/$aa/$ff and four pixels per byte. Uniform source and already-painted bytes are scanned with +8 bitmap cursors, complete span interiors are written whole, and only irregular edges retain masked logical-pixel handling. The governed checked benchmarks reduce large-open hires from 122,093,856 to 2,383,610 cycles (51.22×) and multicolor from 65,897,544 to 2,580,963 cycles (25.53×), with permanent workload-specific ceilings covering small, fragmented, corridor, large-open, and near-full-screen fills.
• Separated bundled Web64 runtime .inc files from C headers in the SDK project tree. They now appear under ASM includes → web64 beside the existing web64/c64lib subtree; opening an SDK document or switching between C and assembly project sources reveals the matching branch and collapses the opposite language branch while preserving nested-folder preferences.

• Markdown and plain-text documents now enable line wrapping automatically when opened. The source-editor toolbar exposes a compact wrapping icon and the editor context menu exposes Wrap/Unwrap commands; either can override wrapping for the current document without rewriting the global editor preference.
• Made native-runtime exact-link discovery use the assembler's actual macro expansion plus explicit bundled-include resolution. Runtime references produced by invoked macros now select their exact module, while references inside unused macro definitions cannot pollute otherwise unrelated closures.

Fixed

• Fixed Map Editor overviews using independently constrained width and height, plus a shrinkable properties-grid row, which could clip lower rows of ordinary and very wide maps. Overview dimensions now follow the live properties-sidebar width, preserve the complete map aspect ratio, keep the overview row at max-content height while the sidebar scrolls, reduce both axes together for tall maps, and horizontally scroll exceptionally wide maps without reserving a black scrollbar gutter.
• Fixed the standalone Trajectory Patterns example's four ping-pong sprites completing and freezing after one round trip. All eight trajectories now remain continuous, mirrored paths stay inside the visible C64 screen, animated colors cannot disappear into the black background, and both C ABIs execute a 600-frame regression run covering more than one complete ping-pong cycle.

2.1.0 - 2026-08-27

Web64 IDE 2.1.0 adds the compact, cycle-gated Trajectory Pattern Runtime and deterministic C90 bit-fields, expands cloud, standalone-emulator, input, and contributor workflows, and preserves the open, selectively linked C/assembly runtime model established by Web64 v2.

Added

• Added the optional Trajectory Pattern Runtime for compact deterministic authored movement. Shared immutable patterns store signed X/Y destination deltas and 1–255-frame durations in three bytes per segment; caller-owned 19-byte states provide independent phase, four-way axis mirroring, forward/reverse/loop/ping-pong traversal, exact endpoints without drift, public transition events, checked/fast calls, _web64_rt windows, and a matching open assembly include. New checked/fast batch entries advance up to 255 contiguous lockstep states into caller-owned event bytes atomically while allowing per-instance X/Y negation. The standalone trajectory-patterns example runs eight independently phased scalar instances and composes the trajectory closure with the existing direct sprite runtime.
• Added deterministic C90 bit-fields for packed Web64 structs and unions. Named and unnamed 8/16-bit integer fields support initializers, direct and pointer access, signed extraction, assignment, compound assignment, and increment/decrement, while address-taking and sizeof on a field diagnose precisely. Extraction and read-modify-write insertion are emitted inline with no hidden runtime dependency; ordinary non-bit-field aggregates retain their existing instructions, data, call cost, and exact closure under both compiler ABIs.
• Added GitHub OAuth as a first-class Web64 Cloud sign-in method alongside passwordless email. The browser returns through the existing canonical Cloud URL, reuses the same Supabase session/RLS boundary, and never exposes the GitHub client secret or refresh token to Web64 workers.
• Added a comprehensive contributors/ onboarding set with a first-day workflow, architecture and ownership reference, focused IDE/asset-editor and compiler/runtime guides, testing and release gates, generated-source rules, troubleshooting, and subsystem entry points for new Web64 IDE developers.
• Added _fastcall int getchar(void) to the tiny <stdio.h> surface. Its selectively linked runtime blocks on C64 KERNAL GETIN, returns the raw unsigned byte as a 16-bit int, performs no echo or hidden character-set conversion, and remains directly callable from assembly as _getchar under both compiler ABIs.
• Added the IDE's independent input routing to the standalone emulator: numpad, arrow-key-plus-Control, or disabled keyboard joystick input has its own port, while physical gamepads 1 and 2 can independently target port 1, port 2, or neither. URL launches expose the same configuration through keyboard, keyboardport, gamepads, gamepad1, and gamepad2, while retaining joystick as a compatible shorthand.

Changed

• Selected generated-table hybrid preparation plus centered DDA for trajectory interpolation from executable 6502 evidence spanning fixed arithmetic, reciprocal assistance, table schedules, phase tables, and zero-table/generated-table hybrid paths. The reproducibly generated 361-byte table set (258 bytes for duration 3; 10/12/14 fractional bytes for durations 5/6/7; 5 integer plus 62 fractional bytes for duration 31) reduces the complete representative workload to 185,085 cycles versus 202,494 for the zero-table hybrid and 207,028 for fixed arithmetic while retaining the 19-byte public state and exact endpoints. The independent 716,485-cycle pointer-based KickAssembler scalar oracle is beaten by 39,684 cycles / 5.539% under web64-static-v0 and 39,703 / 5.541% under web64-stack-v1; linked sizes are 3,214 and 3,296 bytes.
• Added a permanent eight-actor trajectory batch gate that includes legitimate internal preparation, self-modifying operand setup, public writes, and JSR/RTS while excluding C marshalling. All 24 combinations of both ABIs, four code origins, and stable plus both $fb/$fc cold buffer placements preserve exact results: stable worst is 3,481 cycles / 17.710% of PAL and cold/overall worst is 3,786 / 19.261%. The 3,931-cycle 20% target is the acceptance requirement with 145 cycles of margin; 4,914 cycles remains only the absolute 25% rejection ceiling. Scalar calls exact-link only game-trajectory.asm; batch calls add the 2,392-byte game-trajectory-batch.asm module span, force no Actor/Sprite runtime, and keep no private semantic state beyond an instruction-address cache. The focused trajectory suite passes 15/15 tests, including the 13/14/15-state dispatch boundary under both ABIs.
• Kept trajectory interoperability open: header-only projection into existing Motion bodies or Actor Batch SoA positions remains byte-identical to equivalent handwritten public-buffer assignments under both ABIs, and the verified trajectory-to-cull-to-command-to-mux pipeline adds only its five unique exact closures with no redundant Motion or direct-sprite runtime.
• Made configured stdin backends zero-byte selective until getchar is actually referenced. Clarified that #pragma charset encodes source string literals at compile time for consumers such as puts; it does not transform live input.
• Reordered asset tabs to keep Character, Block, and Map Editors together, followed by Sprite Editor. Restyled the standalone emulator with the v2 workstation's neutral surfaces, restrained gradients, compact controls, focus states, panel hierarchy, responsive input layout, and semantic state cues without changing the IDE emulator shell.

Fixed

• Fixed standalone URL-launched disk autorun so a mounted drive-8 image receives LOAD"*",8,1 followed by RUN using the correct host-text-to-PETSCII command bytes. Local development can now launch deployed web64.nofs.ai media through a host-restricted development bridge despite the production host's same-origin resource policy, and launch failures remain visible instead of being overwritten by the normal running status. Launch audio is reasserted after D64/PRG transitions and retried on the first permitted gesture instead of switching straight back off.
• Fixed standalone fullscreen=on being only a passive flag: the emulator now attempts entry immediately and keeps a first-interaction activation path across the complete shell when browser policy requires it. The toolbar pause action now displays a Play icon while paused.

2.0.1 - 2026-08-25

Web64 IDE 2.0.1 completes the _web64_rt convention rollout across the existing native game runtime, repairs typed native-asset address lowering and runtime diagnostic provenance, and ships the manually verified Trike Mania and Egghunt editor/runtime corrections.

Added

• Added web64/runtime.inc, a generated metadata-only assembly reference for every _web64_rt entry and its exact-width named/positional argument symbols. Including it links no runtime code; referencing an entry exact-links only that implementation, its window, and declared dependencies.

Changed

• Extended _web64_rt from the actor/mux/World pilot to all 119 parameterized native web64_* runtime functions: disk/file I/O, fixed-point math, asset copying, motion, collision, animation, direct sprites, sprite multiplexing, actors, actor batches, and World. The three parameterless runtime entries retain ordinary direct labels because they need no argument window.
• Kept argument windows open and deterministic for C and assembly: pure C arguments use direct exact-width placement, side-effectful expressions retain stable ordinary marshalling, high-arity legacy aliases use the compiler's hexadecimal parameter suffixes, and nested runtime calls retain their callee windows through exact closure.
• Reduced the frozen legacy fixed-point call fixture by 78 linked bytes and 52 estimated cycles through direct _web64_rt placement, while preserving its exact helper closure and establishing a new byte-identical golden.
• Re-aligned the exact-linked sprite-mux commit kernel after its new two-byte argument window so the canonical 24-layer PAL schedule remains within one frame with its measured IRQ safety margins.

Fixed

• Fixed _web64_rt declaration validation for aliased descriptor pointers and exact signed-byte arguments without changing the legacy compiler's general scalar semantics.
• Fixed generated native asset descriptors being readable constants but not addressable C lvalues. Charset, sprite, block-set, map, and overlay-pair descriptors now support the typed &asset copy/binding APIs, remain read-only, and exact-link only descriptors actually referenced by lowered C under both ABIs.
• Fixed stale legacy signed-steering references surviving inside the exact-linked Motion closure. Runtime assembly now also carries its owning web64-runtime/*.asm provenance through optimization, assembly, diagnostics, and debugger maps, so a runtime failure cannot be misreported against an unrelated line in main.c.
• Fixed standalone per-block Character and Block previews losing their representative VIC-II Color RAM context, and stopped direct-character maps from reporting an unused legacy block-set path as a missing dependency. Egghunt now declares the bitmap-multicolor screen/Color RAM metadata used by its actual renderer, preserving all sixteen bitmap Color RAM values without weakening text-multicolor rules.
• Regenerated Trike Mania around the current typed asset-copy and _web64_rt runtime contracts. Its relocatable verification builds patch sprite-pointer immediates during setup while the production hot renderer remains cycle-identical; all twelve race combinations now verify exact copied asset bytes, sprite projection, steering, checkpoints, and natural race completion.

2.0.0 - 2026-08-24

Web64 v2 is the largest Web64 IDE release so far: a neutral, adaptive workstation UI; repaired high-performance asset workflows; broader input and navigation; and an open, cycle-measured game runtime that remains fully interoperable with C, Web64 assembly, KickAssembler-style code, and c64lib-compatible projects.

Added

• Added source-navigation history with Back in the editor context menu and Alt+Left. F12, Ctrl+F12, include navigation, generated source mappings, and cross-file/SDK jumps record the exact document, selection, and scroll position without changing project history.
• Added explicit emulator input routing: keyboard joystick can use the numeric keypad, cursor arrows with Control as fire, or be disabled; its C64 port is independent, and physical gamepads 1 and 2 can each target port 1, port 2, or neither. The public runtime status/configuration keeps every route visible.
• Added a PAL Sprite Multiplexer + Overlay Pair project template derived from the standalone example. It demonstrates caller-owned sprite placement and IRQ installation, native atomic overlay-pair submission with independent layer frames, sine-table movement, reserved direct HUD slots, repeated mux-slot reuse, and a deterministic priority drop case.
• Added the open actor-batch runtime: caller-owned SoA views, independent base/overlay animation state, stable visible/pair/command buffers, raw/native sprite bindings, atomic native overlay-pair commands, direct and mux adapters, checked and prepared _fast phase roots, and a fused actor-to-mux root. Every phase retains exact selective linkage and publishes its C/assembly layout from one authoritative definition.
• Added web64/actor-batch.inc as a resolver-only bundled assembler include. External Web64/Kick-compatible assembly can consume or transform the public buffers by named offsets without linking either built-in adapter.
• Added a canonical both-ABI actor-batch benchmark with a competent equivalent handwritten KickAssembler implementation, byte-for-byte output comparison, invisible-actor and general-to-dense probes, closure reporting, mutation ranges, linked bytes, and separate direct-label versus ordinary-C dispatch measurements.
• Added the _web64_rt ABI pilot for registered external runtime declarations. Registry-generated exact-width named argument windows sit immediately before unchanged entry labels, publish named/positional/width/offset symbols for assembly, alias existing generated parameter labels, remain exact-linked per called entry, and preserve stable ordinary marshalling whenever direct placement is not proven safe.

Changed

• Made registered Web64 runtime entry labels first-class mixed-project dependencies. A selected native assembly translation unit may call a public underscore-prefixed runtime entry directly; the same registry-driven exact closure used by C now links that entry and its dependencies without pulling unrelated runtime modules. Assembly comments do not create dependencies, and a caller-owned definition remains authoritative instead of gaining a duplicate runtime body.
• Corrected Block Editor work-bay geometry with a scroll-safe centering container, keeping odd-sized blocks such as 5x5 exactly centered while oversized zoom levels remain reachable in both axes. Removed the obsolete BYTES footer strips from the Character, Block, and Map editors.
• Repaired CharPad CTM text-multicolor import semantics and Map Editor interactivity. Per-project CharPad multicolor state now becomes an explicit bit-3-set Web64 foreground attribute without rewriting per-character/per-block attributes, and native glyph/block raster caches replace millions of repeated per-pixel canvas calls while painting remains transaction-bounded.
• Fixed the editor-to-compiler snapshot boundary so an edited or emptied root main.c immediately supersedes stale source and diagnostics. Explicit serialized root-file records now also supersede divergent legacy root snapshots, and the public SDK exposure gate includes both web64/actor-batch.h and web64/actor-batch.inc.
• Completed the v2 workstation acceptance follow-up: selected Settings modes are more legible, debugger and Sprite Editor structural selection is neutral grey, Character/Block/Map empty headers expose CTM import, Sprite Editor keeps its full new/import header while empty, and asset-editor empty states remain consistent. SID assets now expose validated import-name and load-address editing that updates the binary path, generated include, and C declarations. Project/source title-bar actions advertise their shortcuts and include explicit Save Project As.
• Fixed the standalone actor-batch-arena example startup and visibility contract by using 16-bit home coordinates, clearing a stale VIC raster source before enabling the wrapper, validating mux setup, and keeping a visible reserved direct HUD pair. The unchanged full actor-batch runtime pipeline completed the synthetic 120-frame workload under both static and stack ABIs with motion, independent overlay animation, atomic drops, repeated slot reuse, and reserved-slot preservation.
• Finished the v2 neutral-chrome correction by replacing the remaining shared teal accent path with equal-channel greys across Settings, debugger, Disk/Media, templates, resize/selection chrome, and ordinary SID controls. Semantic project/source/PRG actions, editor tool families, SID voices and transport/playback states remain intentionally colored. All six asset editors now use one centered create-new state with a Lucide graphic, guidance, and a neutral create action. Settings one-line controls now share an exact 28px outer height and wrapped rows retain explicit vertical separation.
• Established the Web64 v2 workstation visual system across Code, Build Targets, Disk/Media, Settings, Character, Sprite, Block, Map, SID Tracker, SID Editor, debugger, templates, menus, dialogs, diagnostics, and status chrome. Shared neutral-grey surfaces, text roles, separators, compact control geometry, stronger but static control gradients, restrained elevation, focus treatment, and motion rules now replace accumulated card-heavy and boxes-inside-boxes styling while preserving workflow-specific semantic colors, dense layouts, keyboard behavior, VIC pixel geometry, emulator aspect ratio, tracker row density, and every compiler/runtime/asset contract. Neutral grey now dominates generic headings, technical values, project-tree selection, and SID Tracker structure instead of teal; selected workspace tabs transition from the real dark workspace surface into their restrained domain color, while project-tree rows remain flat and unmistakably non-button-like. SID voice identity, transport, playback/selection state, and graph accents remain explicit semantic signals rather than becoming generic chrome. Character and Block now share a persistent, resizable properties inspector with adaptive metadata rows, palettes, and larger 3x3 previews. The Block work bay removes redundant decorative and per-pixel grids, supports explicit 1x-32x zoom, centers fitting blocks, and scrolls oversized canvases; Map/SID panels continue responding to their real editor-container width so outer IDE panes cannot clip them.
• Recovered the complete 24-actor/18-visible/four-pair production workload without removing any open buffer or ownership boundary. After adding adjacent runtime argument windows and the stable-topology mux refresh, the direct-label fused pipeline measures 15,020 cycles under web64-static-v0 and 15,026 under web64-stack-v1, versus the frozen 15,338-cycle Kick evidence, while retaining byte-identical semantic output and meaningful 318/312-cycle (2.07%/2.03%) headroom.
• Hardened the canonical actor-batch-arena path end to end: all 32 caller-owned Q12.4 positions move through the open sine/velocity adapter, 18 actors remain visible, four native overlay pairs animate independent layer frames, pairs retain atomic scheduling and higher overlay precedence, six mux-owned slots are repeatedly reused below reserved HUD slots, and stable priority pressure produces the same 9-entry/13-layer acceptance and 9-entry/9-layer drop. The live PAL gate completes 120 consecutive frames with zero busy submissions; its measured application frame is 12,487 cycles.
• Replaced the contradictory 9,828-cycle hard gate with a best-equivalent-oracle contract: Web64 must beat the lower of the frozen 15,338 result and any newly demonstrated equivalent handwritten result by at least the larger of 256 cycles or 2%. The original 9,828 target remains recorded as stretch research. The separate _web64_rt gate reduces the previously measured 756-cycle C-facing overhead to 252 cycles under both ABIs: 504 cycles and 66.67% removed without changing the direct-label measurement boundary.

1.9.2 - 2026-08-23

Changed

• Character Editor palette controls now follow the selected VIC-II display mode instead of exposing one generic four-color layout: Text Hires has background/foreground, Text Multicolor has its two shared colors and Color RAM mode attribute, ECM has all four code-selected backgrounds, Bitmap Hires has its two screen nibbles, and Bitmap Multicolor has background, screen high, screen low, and Color RAM colors in hardware order.
• Switching display modes now initializes the metadata required by the destination mode without rewriting glyph bytes. Text Multicolor promotes default and representative character attributes into the multicolor $8–$f group, while bitmap modes initialize packed screen-color bytes from the project palette.
• Per-character bitmap editing now exposes the packed screen byte explicitly so both bitmap screen colors can be inspected and changed without collapsing the four-value paint palette.

Fixed

• Fixed Text Multicolor opening as a one-bit hires editor after the v1.9.1 attribute correction when a new charset or mode transition still carried a bit-3-clear default foreground.
• Fixed Bitmap Hires and Bitmap Multicolor treating absent screen-color metadata as zero, which collapsed their editor palettes into repeated background colors. Explicit zero screen and Color RAM values remain authoritative.
• Fixed ECM reads, writes, duplication, and character metadata edits addressing unreachable high-bank glyph storage instead of aliasing through the character code's lower six bits; all four ECM backgrounds are now selectable and previewed consistently.
• Added a five-mode regression matrix covering editor geometry, palette ordering, metadata defaults, mode transitions, explicit-zero overrides, mixed Text Multicolor attributes, ECM addressing, and project serialization.

1.9.1 - 2026-08-23

Changed

• Text-multicolor foreground, character, block, and map Color RAM controls now present the C64 palette as two explicit 0–7 groups. The first group selects hires character interpretation and the striped second group selects multicolor interpretation while preserving the raw $0–$f attribute nibble.
• Character, block, map, minimap, selection, and tile previews now share one context-aware VIC-II display-state resolver. The same character bytes can therefore render as hires or multicolor independently in different Color RAM contexts.
• Text-multicolor Color RAM optimization now compares the visible low-three-bit colors only within the same hires/multicolor group and retains at least one representative for every used group.

Fixed

• Fixed text-multicolor Color RAM values $8–$f being rendered as physical palette colors 8–15 instead of multicolor attributes whose visible foreground is value & 7.
• Fixed the Character Editor globally forcing every text-multicolor charset glyph into four-pixel geometry, which prevented mixed hires and multicolor character editing and propagated incorrect previews into the Block and Map Editors.
• Preserved project, generated asset, map-plane, and CharPad CTM5/CTM9 data byte-for-byte: mode selection changes how the existing four-bit Color RAM attribute is interpreted and never rewrites the glyph solely because its hires/multicolor bit changes.

1.9.0 - 2026-08-22

Added

• Added web64_sprite_mux_irq_service_fast() for IRQ dispatchers that already preserve A/X/Y. It retains the mux module's exact independent closure, acknowledges no interrupt source, uses no compiler or call-scratch zero page, and complements the preserving web64_sprite_mux_irq_service() entry.
• Added npm run test:sprite-mux-performance. The alignment-swept benchmark covers both C ABIs, enforces the PAL safety windows, and reports a 49-cycle handler-tail-to-next-compare segment versus 76 cycles for the equivalent bundled Copper64 normal irqHandlersReturn + fetchNext segment.
• Added a both-ABI repeated native asset-pair fixture. It submits ten editor-authored pairs through web64_sprite_mux_submit_asset_pair(), verifies independent descriptor frame pointers, atomic scheduling, overlay precedence, multicolor/mono state, six safe pair-reuse events, nine accepted native overlay pairs as eighteen physical layers, and one atomic two-layer drop.

Changed

• Rebuilt the PAL mux IRQ as a prepared display-list player. Commit now writes 24-byte entries with complete owned-slot VIC control snapshots; the IRQ consumes them through patched low/high absolute-indexed windows, direct slot payload stores, one owned-bit merge per VIC control register, inline entry advance, and inline next-compare arming.
• Reduced measured reuse admission from 15/21 PAL lines to 7 lines for one hardware layer and 8 for an atomic pair. Worst alignment-swept fast call intervals are 283/337 cycles; modeled KERNAL entry and the demonstrated acknowledgement wrapper yield 336/390-cycle end-to-end paths, leaving at least one complete 63-cycle safety line.
• Rebuilt the standalone sprite-multiplexer-overlay field entirely from native pairs. Three simultaneous pairs fill all six owned slots, six later pairs repeatedly reuse them, and a compact unsigned 32-sample sine lookup moves every pair smoothly from side to side at quarter-turn phase offsets without linking the Motion runtime. Independent base/overlay animation streams run in opposite directions through all four frames. Animation state advances only after a successful commit, while a busy pending buffer repeats its complete prior schedule.

Fixed

• Fixed visible sprite flicker by removing repeated generic field-loader calls, pair-duplicated VIC read/modify/write sequences, IRQ-side flag recomputation, and redundant register preservation from the demonstrated KERNAL wrapper.
• Fixed the example proving overlay composition on only one logical sprite. Live PAL verification now rejects cherry-picked frames and requires 120 exactly consecutive complete frames, one line-300 tick per frame, motion and all four base and overlay frames in every one of nine accepted pairs, at least forty bright mono-overlay pixels in every pair region, byte-stable reserved HUD slots, aligned pair layers, six safe reuse events, and the deterministic atomic two-layer drop.
• Fixed generic single-sprite mux submissions being forced to multicolor. Singles now honor WEB64_SPRITE_MULTICOLOR; atomic overlay pairs continue to force a multicolor base and mono overlay.

1.8.0 - 2026-08-22

Added

• Added native C consumption of Sprite Editor .spritepair.json assets, atomic direct overlay-pair rendering, and an independently linked PAL-only sprite multiplexer with caller-owned double buffers, deterministic priority scheduling, slot isolation, explicit status, and application-owned IRQ chaining. Scheduled event/end positions retain the full nine-bit PAL raster range. Reuse admission reserves the complete global end-to-end IRQ interval plus a 63-cycle margin: fifteen lines for one layer and twenty-one for an atomic pair. The standalone sprite-multiplexer-overlay example demonstrates more than eight logical sprites, independent pair animation, reserved direct slots, visible movement, and a stable overload drop.
• Added a complete print-book PDF pipeline that combines every Web64 manual, compatibility guide, SDK header printout, legal notice, and release record behind a dedicated full-page cover, global contents, chapter openers, running headers, page numbers, and PDF bookmarks.
• Added instant cross-manual documentation search with API-aware ranking, category filters, keyboard access, and a fully static index suitable for the remotely served zero-install IDE. The existing documentation shell and contents sidebar remain unchanged, while a compact Manuals dropdown preserves access to every guide and reference without crowding the header.

Fixed

• Fixed PAL sprite reuse compares being scheduled only by unique raster line instead of by their complete execution intervals. The deterministic builder now rejects globally overlapping service windows, uses the measured dispatch/wrapper/runtime cost, and still constructs a feasible 24-physical-layer schedule within one 19,656-cycle frame.
• Fixed mux IRQ dispatch treating the current raster as the compare that caused the interrupt. The service now follows its module-owned armed boundary/event state, so normal VIC/KERNAL entry latency cannot misclassify line 300 or skip a reuse update.
• Fixed the standalone sprite-multiplexer overlay example appearing static, sparsely rendered, or misaligned. Its multicolor base uses the correct 12-cell authoring width, direct and mux pairs share exact geometry, animation commits from the application-owned frame tick, raster events use end-to-end-safe spacing, the wrapper calls the mux service directly from assembly, and live PAL verification now requires two complete visibly different multiplexed frames.
• Fixed pointer members inside packed C structs being omitted from aggregate layout. Web64SpriteMultiplexer now allocates its full 50-byte public ABI—including eight 16-bit PAL slot-end positions—and nested status fields use their correct offsets instead of overlapping adjacent caller storage.
• Eliminated the remaining buffered World scrolling trails and multicolor corruption by removing visible-time Color RAM rebuilds from the moving templates. Buffered examples now initialize a stable region color once, perform zero in-loop Color RAM writes, and leave exact per-cell colors to the static renderer or explicitly raster-scheduled public APIs.
• Replaced the speculative five-page scroller with a transactional two-page renderer. A physical screen page cannot be rendered into or reused until its staged VIC presentation has committed, closing the high-speed/subpixel path that could overwrite the page still on screen.
• Made Motion-composed subpixel scrolling visibly accelerate and brake across 0.125-4.0 pixels per frame. The example retains its authoritative Q12.4 position and lets the renderer consume up to four integer steps per tick without rounded-position feedback.
• Added true screen-only World Runtime entry points for character/block drawing, row/column streaming, shifts, and visible mutation. These variants require no Color RAM or material plane and omit their setup, reads, writes, and runtime traffic entirely.
• Added real Wasm VICE verification at both levels: physical screen/color memory is compared with the native-map viewport, and the actual 384x272 rendered pixel buffer is checked frame by frame for blank frames, collapsed graphics, illegal screen pages, and corruption spikes during four-direction and subpixel movement.
• Fixed the linked scifi-scroller-color-map export by normalizing Kick-style backslash macro parameters to the bare parameter syntax required by the native Web64 assembler; the regenerated example now compiles without the repeated Unexpected character "\\" diagnostics.
• Fixed web64_motion_axis() being unable to accelerate left from exactly zero velocity. Both the native runtime and literal-profile compiler specialization now preserve gradual opposite-direction braking but begin negative acceleration on the next zero-velocity tick, restoring clean joystick reversal in Motion-composed World projects.
• Fixed World fine scrolling exposing unbacked edge cells by selecting the VIC-II 38-column mask for horizontal movement and verified 25-row geometry for vertical movement. Partial transitions stop on their exact fine phase; opposite input reverses that phase one pixel at a time instead of forcing completion and oscillating around the camera target.
• Added deterministic runtime-only frame traces for integer and 0.125-pixel Q12.4 movement. They verify coarse/fine/VIC mapping, exact entering strip addresses, aligned screen/Color RAM writes, forward/reverse boundaries, and zero plane writes on non-boundary and stopped frames.
• Added the World Subpixel Motion Scroller template and linked example. It composes Motion Q12.4 directly through web64_world_camera_sync_x() at a PAL-safe 0.125-1.0 pixels/frame, with measured acceleration, braking, reversal, deterministic settling, and no rounded-position feedback.
• Fixed every new World project appearing to ignore the joystick after its first update. A direct byte-pointer raster comparison was incorrectly promoted by reading $d012 and the adjacent $d013 register as one 16-bit value, trapping wait_frame() forever. Byte pointer promotions now read exactly one byte and zero/sign extend it, the World frame waits use explicit byte samples, and an optional live Wasm VICE route verifies sustained joystick motion in all seven interactive templates plus the static-map controller.
• Fixed the multicolor platformer horizontal body probe overlapping its floor-contact row, which could make grounded movement stop as though the floor were a side wall.
• Kept the Motion-based actor and platformer examples within the one-pixel-per-frame buffered-camera contract, so the player cannot outrun the renderer and disappear before the camera catches up.
• Recreated every Game Runtime World template and all eight linked web64-examples projects around the transactional double-buffered renderer. The displayed VIC screen is immutable, the complete next viewport is generated offscreen, and page/fine-scroll state is committed together during the frame boundary. This removes visible-screen shifting, character tearing, color flicker, and repeated terminal rows or columns.
• Fixed World video ownership by disabling inherited KERNAL/CIA cursor interrupts, setting multicolor mode deterministically, keeping moving templates on stable region Color RAM, preserving exact per-cell Color RAM in the static renderer, and keeping the supplied player sprite in hires mode independently of the character-screen mode.
• Rebuilt the World platformer as a playable Game Runtime integration: visible material-backed floors and platforms, joystick acceleration/braking, gravity, grounded fire/up jumping, collision probes, a recognizable hires player, and smooth clamped camera following.
• Added explicit physical-page origin records and transactional present state to the generated scrollers, allowing tests and debuggers to distinguish prepared, staged, and displayed viewports without inferring ownership from logical camera state.
• Enabled browser gamepad polling by default in every World example and template while keeping the numeric-keypad joystick active at the same time. Port 2 input is now covered end-to-end from the browser input controller through the emulator bridge and the generated C gameplay routines.
• Replaced the old synthetic World performance report with sustained 6502 execution gates. Worst measured frames are 14,499 cycles horizontal, 17,708 vertical, 15,223 bidirectional, and 14,746 multicolor bidirectional—51.305% to 62.041% below the frozen visible-shift paths and all below one PAL frame. The composed subpixel Motion + World path peaks at 16,083 cycles. Displayed-screen and in-loop Color RAM writes remain zero.

1.7.0 - 2026-08-17

Added

• Added the Web64 Game Runtime World module family for native asset maps, static viewport rendering, fine-scroll camera stepping, high-speed row/column screen streaming, and visible map mutation through <web64/world.h>. Like Motion, Collision, Animation, Sprites, and Actors, World retains independent runtime closure.
• Added first-class native asset wrappers for .w64chr, .w64blk, .w64map, and .w64spr so they open in the correct editors, remain editable project-tree files, and still produce deterministic build artifacts.
• Added Game Runtime World-module project templates: World Static Map, World Horizontal Scroller, World Vertical Scroller, World Bidirectional Scroller, World Multicolor Platformer, and World + Motion and Sprites, with creation options for color mode, Color RAM policy, and camera bounds.
• Added npm run test:world-runtime-performance, publishing complete Game Runtime World-module boundary-frame comparisons: horizontal shift-plus-column rendering measured 38,196 cycles versus 137,096 for the former generic path (72.139% fewer), while vertical shift-plus-row rendering measured 36,365 cycles versus 104,373 (65.159% fewer). The isolated column streamer measured 5,349 cycles and the row streamer measured 4,444 cycles; no-boundary frames perform zero screen RAM writes and zero Color RAM writes.
• Added Game Runtime World-module reference tables, web64/world.h SDK reference output, and printable public/docs/headers/web64__world.h header listings to the published documentation.

Fixed

• Fixed black screens and execution becoming trapped in the Game Runtime World module by keeping World template payloads and software stacks out of the C64 BASIC ROM window and by preventing stack-ABI runtime temporaries from overwriting the compiler frame pointer.
• Replaced generic frame-loop memory movement with exact-closure Game Runtime World copy and fixed-width screen/Color RAM shift kernels, regenerated all seven portable World examples with embedded native assets, and verified static, scrolling, multicolor, platformer, and actor-camera projects through the remotely served IDE.

1.6.1 - 2026-08-16

Fixed

• Fixed KickAssembler Compatibility Mode treating hash-prefixed boolean literals such as #True and #False as undefined preprocessor symbols. They now parse as compile-time booleans and lower to 1/0 in emitted data and immediate operands.

1.6.0 - 2026-08-16

Added

• Added the Web64 Game Runtime library family for composition-first C game code: shared Q12.4 game types, subpixel motion helpers, material-map collision APIs, deterministic animation playback, direct eight-sprite rendering, actor-pool utilities, and explicit opt-in composition helpers.
• Migrated the canonical Egghunt and Greedy Ghost examples in the linked web64-examples repository to the Game Runtime libraries and recorded the release performance gates: Egghunt beats its required 20% hot-path reduction, and Greedy Ghost beats its required 15% reduction.
• Added Web64 Game Runtime quick-reference tables to the C compiler manual, covering module dependency closure, primary calls, flag groups, explicit game-loop sequencing, and direct links to printable SDK header listings.
• Added a dedicated Web64 Game Runtime Libraries documentation page and top-bar manual link so the new libraries are directly reachable from the Web64 documentation landing path.
• Added generated Web64 SDK header printouts under public/docs/headers/ plus a dedicated web64-sdk-header-printouts.html page with exact bundled C header listings.

1.5.2 - 2026-08-16

Added

• Added 21 workflow-focused screenshots to the Web64 IDE manual, covering project creation, source and generated assembly, build targets, debugging, disk mastering, Web64 Cloud, settings, asset editors, image conversion, and SID workflows. Every figure includes descriptive alternative text, a focused caption, responsive sizing, lazy loading, and print-safe layout.

Changed

• Enlarged the Web64 documentation logo across the browser manuals and made the top navigation expose the Web64 IDE, C compiler, SID tracker, and Kick compatibility manuals directly.

Fixed

• Fixed Tab replacing a multiline C or assembly selection with a single tab. Tab now indents every selected logical line, Shift+Tab removes one indentation unit, and the selection remains active without changing single-caret Tab behavior.

1.5.1 - 2026-08-16

Fixed

• Restored KickAssembler-compatible ; statement separators after a line-comment heuristic dropped trailing data directives in real projects. This fixes the Blue Vessel c64lib demo's hscroll terminators and restores byte-for-byte parity with the official KickAssembler 5.13 PRG.
• Kick compatibility comments now consistently use // and /* ... */. CodeMirror, the fallback highlighter, immediate diagnostics, context-menu comment commands, and keyboard shortcuts follow the active dialect; native Web64 assembly continues to use ; line comments.

1.5.0 - 2026-08-15

Added

• Added New > Kick-compatible assembly project... to the project tree. It creates one Web64 assembly root with an explicit KickAssembler Compatibility target and automatically exposes the bundled Kick c64lib sources as read-only SDK files without implying that Web64 embeds or runs Kick Assembler.
• Added explicit per-Build-Target KickAssembler 5.25 Compatibility Mode for pure assembly projects, with a browser-local typed compile-time evaluator for functions, variables, mutation, conditionals, loops, preprocessing/imports, macros, collections, structures, namespaces, diagnostics, data generation, pseudo commands, layout, segments, and declarative artifact contributions.
• Added the evidence-backed v5.25 compatibility manifest, migration/support guide, IDE compatibility reports and telemetry, a public kick-assembler-v5.web64proj example, a pinned direct-source c64lib/chipset MOS 6510 P0 checkpoint, and a maintainer/CI-only differential oracle with paired positive/negative P0 fixtures and a stable native-assembler snapshot.

Changed

• Kick compatibility builds now use deterministic effect convergence, dependency-selective replay, stable console/diagnostic delivery identities, worker-local immutable caching, cooperative cancellation, finite resource budgets, and physical/logical debugger provenance. Web64-native assembly remains the default, and C or mixed C/assembly builds remain native.
• Compatibility adapters lower only neutral emission, CPU/addressing, layout, and artifact records; evaluator values, scopes, effects, replay/cache state, diagnostic-delivery state, and performance telemetry do not enter the neutral IR or 6502 backend.
• Completed the project-tree, Kick-compatible project, and source-debugger user-manual workflows. The explicit documentation-release command regenerates a print-styled, tagged, outlined PDF from current HTML, while zero-install remote builds validate and reuse the version-matched committed PDF when Chromium is unavailable.

Security

• Confined Kick imports and compile-time data to immutable project-VFS inputs and rejected Java/plugins, external processes, arbitrary host files, unrestricted network access, custom writers, and v6 preview semantics. The remotely served IDE remains zero-install and never ships, fetches, or runs the separately supplied maintainer oracle. Paired P0 differential evidence is verified without claiming general KickAssembler binary equivalence or blanket c64lib source compatibility.

1.4.1 - 2026-08-14

Added

• Added source-oriented C and ASM debugger breakpoints that remap after compilation, paused-PC source following, exact instruction stepping, safe call step-over, typed global/local inspection, and an address-navigable memory viewer.
• Added canonical drag reordering for characters and blocks with dependent map/block reference remapping, selection/history preservation, and save/export compatibility.

Changed

• Character, block, and direct-character map palettes now reflow with their resizable collection panels instead of requiring fixed-column or horizontal-scrolling layouts.
• Redesigned Build Targets into compact responsive groups and applied the complete purple interaction palette to Build Target and Remove actions.
• Simplified the project tree with larger monochrome open/closed folder icons, removed redundant state labels, enabled dragging virtual files between folders while preserving linked project references, and made the target summary identify the active runnable artifact.

Fixed

• Fixed source breakpoints whose VICE monitor stop reports the post-instruction PC: the debugger now retains an unambiguous breakpoint execution address and hydrates missing optimized line-map function/scope fields from compact debug origins, keeping C locals attached to the correct function while continuing to display the authoritative current PC.

1.4.0 - 2026-08-14

Added

• Added the versioned Web64-C optimizer platform: five canonical profiles, ABI-aware zero-page ownership, authoritative instruction/cost records, gated typed function/block/value IR with ordered effects and provenance, and deterministic Egghunt/Greedy Ghost benchmark routes.
• Added exact public/private/data-section native runtime closure rooted in surviving lowered imports, so a single string, ctype, stdlib, stdout, arithmetic, or fixed helper no longer links unrelated routines.
• Added typed constant builtin specialization for literal strlen, signed abs, and ASCII ctype predicates/conversions, plus optimizer traces that distinguish emitted transformations from analysis-only consumers.

Changed

• Added profitable non-power-of-two 16-bit constant multiplication and dynamic fixed 8.8 absolute-value lowering while preserving signed truncation, two's-complement wrap, single evaluation, and exact helper closure.
• Removed the duplicate fixed-point source preparse; typed lowering and final lowered imports are now the specialization and runtime-selection authority.

Fixed

• Fixed pointer and generated-asset subscripts losing the high byte beyond offset 255; ordinary pointer parameters now preserve pointee typing and call-valued indexes execute exactly once under both C ABIs.

1.3.0 - 2026-08-13

Added

• Added mutable generated C asset payload arrays and typed views, including single-evaluation function calls in flat and multidimensional subscripts.
• Added raw-value and unsigned 8.8 conversion macros to web64/fixed.h.
• Added guided standard GoatTracker 2 import for GTS3-GTS5 songs and GTI3-GTI5 instruments, including project-tree import, append/replace instrument choices, timing/SID/backend settings, and GTS5/GTI5 export from editable W64SID state.
• Added W64SID v3 typed GoatTracker orders, raw speed tables, exact instrument gate/first-frame fields, no-instrument-change pattern cells, and adaptive event-stream/interpreter backend selection.

Changed

• Optimized 16-bit constant multiply/divide/remainder and fixed 8.8 power-of-two operations into inline shifts, masks, and negation while preserving signed truncation semantics and dropping unused runtime helpers.
• GoatTracker playback now advances voice orders and rows on independent tempo clocks, executes pattern and wave-table commands, and preserves transpose, repeat, restart, funk-tempo, filter, pulse, vibrato, and portamento behavior without changing native Web64 song paths.

Fixed

• Fixed signed 8-bit values and byte-returning functions being zero-extended when promoted into 16-bit expressions, and retained side effects in fixed multiply-by-zero specialization.
• Fixed nested VIC->, SID->, CIA1->, and CIA2-> register-member reads in Web64-C expressions, conditions, arguments, and returns, and preserved aggregate layout for file-scope user struct pointers.
• Fixed standalone Character Editor and character-palette colors for per-cell Koala, PNG, and Cloud map imports by preserving representative Color RAM/video-matrix metadata and reconstructing it from existing cloud map bundles.
• Fixed Cloud project deletion across mixed deployment versions by adding a forward database RPC repair and an authenticated, owner-checked Cloud API fallback when PostgREST has not exposed the deletion RPC.

1.2.1 - 2026-08-10

Fixed

• Fixed bitmap-to-block conversion so derived block maps receive a foreground-pixel-weighted best-fit Color RAM plane instead of defaulting every block to color 1.
• Fixed Map Editor paste placement so a floating paste starts at the active selection instead of a stale top-left cursor, and now previews copied graphics with their Color RAM/video values plus the active metadata-plane overlay while being positioned.
• Fixed Web64-C user-defined functions such as plot_pixel being mistaken for legacy compiler intrinsics, added runtime-count right-shift and indexed byte-pointer compound-assignment lowering, and replaced generic unsupported-expression failures with specific syntax and pointer-type diagnostics.

1.2.0 - 2026-08-08

Fixed

• Fixed legacy Web64-C project migration so generated _start machine-entry labels are not misinterpreted as externally linked C functions.
• Fixed unnamed legacy Build Targets producing the unusable output filename .prg; migrated targets now receive a valid default filename.
• Fixed Cloud Map Asset import so immutable versions restore their complete Color RAM, video-matrix, and material planes instead of reconstructing only structure data.
• Fixed the Map Editor overview for direct-character maps by rendering the linked charset, wide character indexes, per-cell color data, and block dependencies instead of index-only placeholders.
• Fixed Map Editor stamp capture so releasing the capture gesture enters stamp mode without painting or shifting the captured region.
• Fixed extended character palettes and direct-character map painting so character indexes above 255 remain selectable, editable, and are stored using wide map indexes without truncation.
• Fixed the Copper64 double-IRQ stabilizer corrupting the KERNAL return stack, which caused the Copper Raster Split template to exit to READY. shortly after launch.
• Fixed the W64SID Music + SFX project template so its embedded SID payload is copied from the PRG to the generated $1000 load address before the player init routine is called.
• Added a saved audible phrase to the W64SID template and enabled audio in its persisted emulator settings, so a newly created project produces sound immediately after Start.

Added

• Added native PNG-to-Char/Block/Map conversion with nearest C64 palette mapping, optional ordered dithering, hires and logical/display multicolor sampling, arbitrary image dimensions, and configurable block sizes.
• Added 2x2 bitmap dicing for 160x200 and 320x200 sources with an explicit top/bottom row crop choice, plus color-resolved companion charsets for visually complete block maps.
• Added an optional translucent Color RAM entry overlay with adjustable opacity in the Map Editor.
• Added rectangular Map Editor selections with move, copy, paste, duplicate, delete, commit, and cancel operations plus independent Structure, Color RAM, Material, and Video matrix plane controls.
• Added selection-wide material set, clear, and replace commands, colored material visualization, and configurable graphics onion-skin opacity.
• Added a dedicated Map Editor bitmap import action that invokes the shared Koala/PNG native conversion workflow.

Changed

• Migrated the legacy web64-examples project manifests to the current version-4 project and Build Target contracts, with runnable C and mixed-language startup paths.
• Virtualized extended character palettes and isolated the map overview cursor from its cached base rendering so large charsets and maps avoid full-content redraws during normal interaction.
• Bounded selection drag updates to animation frames and retained charset/block render caches across map viewport redraws.

1.1.0 - 2026-08-07

Added

• A first-class project template catalog for realistic Assembly, Web64-C, and mixed-language projects, including native-asset game, scrolling, audio, disk, cartridge, demo, and SDK foundations.
• Horizontal and vertical ASM and mixed scrolling templates now expose a creation-time Color RAM choice between the fast uniform region path and verified per-cell native map colors.
• Template manifests now record architecture rationale, performance contracts, provenance, required modules and assets, and recommended next templates without creating mutable dependencies for instantiated projects.
• Public Web64 Cloud profiles with immutable handles, optional display information, privacy controls, and square avatar editing.
• Public profile pages at /u/<handle> without exposing account email addresses or internal user IDs.
• A governed project changelog available as Markdown, generated HTML, in the Web64 IDE manual, and directly from the About dialog.

Fixed

• Fixed Map Editor Color RAM creation so a new per-cell color plane inherits the map's visible block or character foreground colors instead of replacing every untouched cell with background color 0; affected existing maps can use the previewed, undoable Restore inherited colors action.
• Removed the smooth-scroller sawtooth row by reloading a reserved blank glyph after every HUD Color RAM write; verification now checks every HUD cell and its rendered glyph in both screen buffers.
• Restored direct VIC->, SID->, and CIA1-> register-struct access under Web64 C90 macro expansion, including use through <web64.h>.
• Corrected native tile template rendering: Tile2 now adapts interleaved blocks into runtime quadrant planes and installs its charset, while the tile/map foundation expands complete 2x2 blocks and Color RAM instead of treating map cells as characters.
• Replaced placeholder noisy template glyphs with deliberate marker, stone, brick, stripe, and edge tiles, and added machine-level output checks for every ASM and C scrolling template.
• Corrected PostgreSQL avatar-path validation so canonical profile uploads can be committed after storage verification.

1.0.0 - 2026-08-07

Added

• Web64-native c64lib compatibility modules, declarations, migration diagnostics, examples, and generated compatibility manifests.
• Browser-native GoatTracker SNG import/export, Exomizer compatibility, Tile2 scrolling support, and Copper64 runtime infrastructure.
• C and assembly interoperability through the existing Web64 ABI, including module dependency and native-path regression checks.
• Dedicated c64lib compatibility documentation and license notices.

Changed

• Completed the c64lib v1 closure gates with deterministic processor, runtime, code-size, and native-path verification.
• Expanded Web64 C character literals and compile-time PETSCII/screen-code string support.

0.8.1 - 2026-08-06

Fixed

• Prevented duplicate generated asset symbols when CharPad files contain related charset, block, and map data.
• Corrected charset-only and blockset-only CTM export/import behavior.
• Preserved charset and blockset dependencies when exporting maps or blocks to CharPad files.

Added

• CharPad CTM import and export for supported versions, including character sets, blocks, maps, color data, and metadata.
• Coordinated Char, Block, and Map editing with shared asset-family relationships and undo history.
• Koala image conversion, color optimization, large-map rendering, and fixture-backed format verification.

0.6.0 - 2026-08-06

Added

• Web64 Cloud Terms of Service and Privacy Policy with links in authentication and About surfaces.
• Cloud Files source preview, version history, rename/overwrite conflict handling, and editable imports.

Fixed

• Restored C and assembly diagnostics used by the debugger and generated instruction mapping.
• Corrected cloud asset include generation and imported asset naming/path behavior.

0.5.0 - 2026-08-05

Added

• Web64 Cloud projects, revisions, restore points, private assets, reusable files, storage reporting, and account management.
• Free cloud tier with limited projects, library items, and storage.
• Semantic cloud asset metadata and dependency bundles for sprites, character sets, blocks, maps, and SID assets.

Changed

• Hardened the production build with public configuration validation, opaque production bundles, and deployment audits.
• Made cloud projects save through their cloud authority while retaining portable .web64proj export.

Earlier Development Milestones - 2026-07-19 to 2026-08-02

Added

• Web64 C with the C90 frontend and stack ABI, multidimensional arrays, fixed-point support, SDK headers, asset declarations, and mixed C/assembly projects.
• Read-only Generated Assembly with source provenance, breakpoints, debugger navigation, and lazy virtualized rendering.
• CodeMirror 6 editing, completion, diagnostics, context menus, table/matrix generators, file navigation, and responsive editor state.
• Sprite, character, block, map, SID Tracker, and SID Editor workflows with project persistence and generated includes.
• Build targets, D64 disk mastering, multi-load projects, keyboard joystick input, emulator controls, and production documentation.

This earlier section summarizes pre-release development rather than assigning version numbers that were not recorded by the repository.