Abstract
Legacy emulators preserve detailed hardware models within applications whose operating-system dependencies can obstruct reuse and verification. In VCC Plus, I separate the Windows-oriented Virtual Color Computer engine into explicit processor, memory, machine-service, and video contracts. A serialized native macOS host composes those components. The extraction exposed defects in instruction operand timing, reset state, interrupt lifetime, raster bounds and storage transfers. Additional CMOC corrections account for effective-address dependencies and condition-code liveness that arithmetic-only optimizer reasoning had discarded. The resulting development platform binds debugging interpretations to executable bytes, compiler metadata, physical mappings and immutable machine observations. It supports conservative stack and variable inspection, bank-aware source debugging, interpreter-aware BASIC stepping, historical tracing and bounded call-context inspection. Process-isolated workers add field-counted input, retry-safe control and graphics/audio evidence without sharing the user's running machine. Guest-library ownership contracts and transactional disk editing extend the same discipline to mappings, interrupts and writable media. I evaluate the design through mechanism-specific regressions, observation-invariance checks, a bounded XRoar comparison, and target-executed compiler cases. A correctness-gated optimization study connects measured code size and guest cycles to the tradeoff between frame omission and inspectable storage. The results show how host decoupling and evidence-backed runtime interpretation can reinforce one another while retaining a mature emulator's useful implementation.
Keywords: emulator architecture; legacy software modernization; Color Computer; MC6809; HD6309; source-level debugging; runtime observability; differential testing.
1. Introduction
An emulator is simultaneously a software application and a model of another computer. Its menus, windows, audio devices, and persistent files belong to the host environment; its instruction execution, memory mapping, interrupts, raster generation, and peripheral protocols describe the guest. In a long-lived implementation, those responsibilities often grow together. Hardware models call application utilities, register code reaches debugger windows, and a display surface carries both pixel storage and host-window state. Such integration can be practical within the original application while making later reuse and independent verification difficult.
VCC, the Virtual Color Computer, embodies substantial prior work on the Tandy Color Computer 3 and its MC6809 and HD6309 processor configurations. VCC Plus is an independent evolution of that codebase. My engineering objective was to retain the useful emulation code while supplying a native macOS application, selected expansion-device support, and development workflows appropriate to that host. The work did not begin as a processor rewrite or as a general Win32 compatibility layer. Its architecture instead makes previously implicit relationships explicit and places host responsibilities behind interfaces or native adapters. The retained Windows application and upstream authorship remain part of the project's provenance. [1, 2, 6]
Platform extraction also created an opportunity to examine behavior independently of a running graphical application. Authored memory buses, recording host implementations, headless machine sessions, framebuffer guards, and bounded execution made defects reproducible at smaller scopes. Some defects concerned conventional software safety, such as initialization order or buffer bounds. Others affected guest-visible behavior: the selected processor used for floating-bus reads, instruction timing after HD6309 reset, actual advancement of a multi-sector floppy transfer, or the position of an operand read within a nominally correct instruction-cycle total. Compiler regressions likewise require attributing wrong program results to generated instructions rather than to input devices or the emulator itself. These differences matter because a successful boot is a weak substitute for a precise account of what has been preserved or changed. [49, 50, 51, 52, 53, 54, 55, 56, 57, 58]
The resulting system also extends substantially beyond host replacement. A debugger needs access to registers and memory, but access alone does not establish the meaning of the observed bytes. A logical address can refer to several physical banks over time; a function symbol may identify an assembly prologue rather than an executing C statement; a stack word can be data rather than a return address; a readable pointer can outlive its object. VCC Plus therefore adds services that bind interpretation to an identified machine, build, mapping, and observation. Their design favors a supported partial answer over an apparently complete but unjustified one. [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
I make four connected contributions. First, I document an incremental architecture for separating a retained emulator from its original Windows host. Second, I analyze substantive correctness changes with causal explanations and mechanism-specific regressions. Third, I describe a debugging and development service layer spanning the core, native bridge, compiler integration, guest SDK, and scoped external tools. Its contracts govern both interpretation of state and temporary ownership of guest hardware. Fourth, I establish execution and resource-ownership contracts for isolated programmable investigation, guest hardware services and transactional media editing. I test these contracts and corrective mechanisms against explicit observable expectations.
I organize the report around four questions. RQ1: Which boundaries permit host replacement while preserving the useful machine model? RQ2: Which correctness problems become observable through extracted subsystem and complete-machine tests? RQ3: What evidence is required before a debugger can associate runtime state with source locations, frames, or typed values? RQ4: How can the same engine support ordinary interactive use and isolated programmable investigation without conflating their state or authority? Sections 2–4 address the first question and method. Sections 5–7 develop the observation and development services. Section 8 analyzes corrective cases, transactional editing, and an integrated guest application. Section 9 reports the evaluation, and Section 10 discusses what its results establish.
I use the following terms with specific meanings. “Portable” refers to the extracted contracts and implementations exercised by the stated hosts; it does not mean that every remaining source file is independent of its original platform. “Verified” refers to implemented identity, mapping, metadata, and byte-consistency checks; it does not denote a formal proof of emulator or debugger soundness. “Compatible” refers to an identified workload and observed path unless broader evidence is supplied. These distinctions allow a technical account of substantial functionality without converting a successful development checkpoint into an unsupported universal claim.
2. Background and Baseline
2.1. The emulated machine and the preservation problem
VCC models the Tandy Color Computer 3 and selected expansion hardware. Its principal execution engines implement the Motorola MC6809 and the Hitachi HD6309, while the machine model supplies memory mapping, GIME/SAM video and timing behavior, peripheral interface adapters, cartridge routing, and storage devices. These components are interdependent. A processor instruction can address a peripheral rather than ordinary RAM; a peripheral read can acknowledge an interrupt; a memory-map change can alter the executable bytes at an unchanged logical program counter; and an instruction's event scheduling can affect when a video-status bit becomes observable. Consequently, preserving an emulator requires preserving relationships among components as well as their individual algorithms. [1, 2]
The inherited implementation already embodied substantial engineering knowledge about these relationships. The purpose of VCC Plus was therefore to retain and qualify useful implementation rather than reconstruct the machine through an unrelated rewrite. The project introduced a native Mac application around the existing C/C++ engines and selected device models. SwiftUI and AppKit provide the application interface; an Objective-C++ boundary connects that interface to the machine owner; Metal presents completed images; and native audio facilities consume samples generated in emulated time. The architectural problem was to make those substitutions without allowing the replacement host facilities to redefine the emulated hardware. [1, 3]
I distinguish host portability, which concerns where the emulator can run, from guest compatibility, which concerns how Color Computer programs behave inside it. The host application and the emulated processor have separate responsibilities in the design. [1, 2]
2.2. Source baseline and inherited Windows integration
I examine the VCC Plus implementation and engineering records reviewed on November 12, 2026. Source citations identify files in the VCCPlusOSS distribution; named product versions and validation dates distinguish the evaluated configurations. Historical development records describe earlier extraction and integration checkpoints; their measurements remain associated with those checkpoints. I use the current source to establish the implemented interfaces and ownership relationships, and dated records to establish the corresponding historical observations. This separation avoids treating an early diagnostic configuration or an earlier suite's test count as a description of every later version. [1, 2, 3, 4, 5]
The original application integrated hardware emulation with Windows application state and services. Processor code depended on debugger state maintained by the application; video code accessed display state; ROM selection and loading were associated with Windows configuration and file handling; and expansion devices were integrated through dynamically loaded libraries and native menus. These dependencies crossed the intuitive boundary between a hardware model and its user interface. Replacing only the main window would therefore have left application assumptions embedded in the execution path. [1, 2, 6]
Windows reference binaries and retained source require separate qualification: a pre-existing release binary cannot be assumed to represent every later source change. Selected Windows workload observations are therefore distinguished from authored architectural expectations and Mac integration tests. Upstream authorship, notices and the retained Windows host establish provenance; complete runtime parity requires additional comparison.
The revised repository separates shared implementation under src/core/
and src/devices/
from the native Mac host under platforms/macos/
and the retained Windows implementation under platforms/windows/.
This organization makes responsibility more visible, but directory
placement alone does not prove platform independence. Shared
host-adapter files still contain conditional Windows implementations,
and some public C++ names retain the VCC::Mac namespace to
avoid an unrelated naming refactor. Portability is established at the
selected build and interface boundaries rather than inferred from
directory or namespace labels. [6, 7, 8, 9]
2.3. Scope of the architectural transformation
I set out to build a native macOS application around the retained emulator. File panels, application settings, keyboard delivery, display submission, audio output, and asynchronous user-interface updates were implemented using host-appropriate facilities. Existing machine algorithms were retained where practical and connected through explicit operations. The project did not require Windows DLL binary compatibility, a third-party Mac plug-in ecosystem, physical floppy passthrough, or automatic parity with every historical expansion module. Device support was chosen according to the product scope and qualified against documented workloads. [1]
This choice separates hardware compatibility from implementation packaging. A Multi-Pak Interface is an emulated arrangement of devices, signals, and routing registers; it need not be implemented by loading a Windows DLL. Conversely, replacing a DLL with a native menu is insufficient if the device's register behavior, interrupt participation, or independent routing is lost. The Mac architecture therefore preserves the relevant device and bus contracts while replacing operating-system-specific discovery, configuration, and presentation. [1, 10]
3. Engineering Objectives and Method
3.1. Preservation through explicit boundaries
My first objective was to retain the inherited execution and device logic while making dependencies explicit enough to compile, execute, and test the selected machine without a Windows application. My second objective was to integrate that machine into a responsive native interface without introducing unsynchronized access to legacy global state. My third objective was to create inspection and development facilities that could make justified claims about the executing program. These objectives are related: a debugger cannot produce consistent observations if the host can read changing core state directly, and independent subsystem tests cannot isolate a defect if application services remain implicit. [2, 3, 4, 5]
I organized the extraction in stages of increasing integration. Processor checks initially used an explicit flat-memory bus to exercise instruction behavior. Machine checks then used the real MMU, hardware registers, and interrupt paths while replacing external connections with recording hosts. Graphics checks added the real renderer and event scheduler. A synchronous session owner connected the resulting components, and the asynchronous native bridge exposed controlled commands and owned observations to the application. Real-ROM boot and selected software workloads followed these authored checks. For each layer, I record the replacement components and the limits of the evidence. [2, 3, 4, 5, 11]
The flat test bus is especially important to this method. It is an explicitly installed override rather than the application's normal memory implementation. Ordinary CPU accesses dispatch through the real MMU when the override is absent. Isolated checks detach the override before a machine integration runs, and the synthetic bus is excluded from the application target. Thus, a test harness can isolate instruction behavior without silently changing the machine shipped to users. [2, 7]
3.2. Change classification and observable contracts
I distinguish three classes of change. A behavior-preserving extraction changes where a dependency is expressed while retaining the intended machine behavior. A corrective change alters an implementation shown to violate a stated expectation, such as reset state or an observable instruction-sampling point. A host or device adaptation introduces a deliberate policy, such as bounded work or deterministic media handling, whose correspondence to the inherited implementation must be stated rather than assumed. New native integration can also contain defects of its own; those are not attributed to upstream VCC merely because the integration uses its machine engines.
I define the contracts through observable effects. For example, the retained CPU execution functions return unused cycles, and a final instruction can exceed a requested budget. A caller must therefore interpret a negative remainder as an overshoot, rather than assuming the request is an exact instruction boundary. A soft reset preserves RAM at the reset boundary but does not guarantee that guest warm-start code will leave every byte unchanged after execution resumes. A frame snapshot owns a completed image but is not a serialized machine checkpoint. Defining these distinctions constrains both implementation and evaluation. [2, 5, 12]
I combine authored fixtures with integration workloads in the validation. Authored fixtures provide known memory contents, instruction sequences, register transitions, and expected timing relationships. They permit source-controlled reproduction without redistributing private ROMs or applications. Integration workloads demonstrate that the composed implementation performs a useful sequence, such as booting an interpreter and executing a program through emulated input. Neither layer replaces the other: a booting application may miss a rare arithmetic defect, while a collection of isolated register checks may miss an incorrect connection between correct components. I report the narrowest conclusion supported by each result. [2, 3, 4, 5, 11]
3.3. Evidence and reproducibility boundaries
I distinguish source inspection, historical execution records, and new demonstrations prepared for the paper. Source inspection establishes that a mechanism exists at the recorded revision. A dated validation record establishes that a particular check was reported as executed in its stated environment. An illustrative harness can explain or exercise a selected algorithm without establishing complete-machine accuracy. The architecture described here relies on the first two forms; it does not imply that all historical experiments were rerun during preparation of the manuscript.
Some integration fixtures require separately supplied ROMs or software. Their absence is a reproduction dependency, not a reason to substitute synthetic evidence while retaining the stronger compatibility claim. The repository therefore keeps public authored checks separate from optional-input probes and preserves notices and provenance for imported implementation. Broader source publication and distribution of third-party payloads remain distinct matters. [1, 2, 11]
4. Architectural Refactoring and Host-Platform Decoupling
4.1. Processor memory and debugger interfaces
CpuMemory.h
states the byte, word, and map-selection operations used by the
processor engines. CpuMemory.cpp
dispatches to MmuRead8, MmuWrite8, and the
real map-selection implementation unless a CpuMemoryBus
override is installed. Word accesses compose byte operations in guest
order, including 16-bit address wrapping. The separation removes the
need for a processor engine to know how a host window, configuration
object, or test executable obtains memory. It also preserves I/O routing
through the machine's actual address decoder during normal execution.
[7]
CpuDebugHooks performs an analogous extraction for
execution observation and control. Its synchronous interface includes
halt state, stepping, breakpoint eligibility, source-step notifications,
trace capture before and after execution, interrupt observations,
video-event notifications, and diagnostics. The CPU engines can invoke
these hooks without including debugger-window definitions. On Windows,
the default implementation forwards to the retained application
debugger. On non-Windows builds, the default supplies a minimal halt
latch, while the native machine owner installs the hooks required by its
debugging facilities. [8]
The hook interface is an integration contract, not a synchronization mechanism. The host owns the installed object and must retain it through execution. Installation and detachment occur outside active execution on the owning thread. This requirement prevents an abstract interface from being mistaken for thread safety: an interface can remove platform includes while leaving the original processor state global and nonreentrant. The same distinction applies to the isolated memory bus. [2, 7, 8]
4.2. Machine-service dependencies and ROM provisioning
MachineHost makes the remaining connections from the
MMU, PIAs, and GIME/SAM registers explicit. Its required methods cover
internal-ROM provisioning; cartridge memory and port access; cartridge
audio; video and timer register delivery; CPU speed selection;
selected-CPU state; interrupt assertion and clearing; keyboard scans;
joystick strobes; tape input and motor signals; and printer bits. A
recording implementation can supply known inputs and observe outgoing
requests, while a complete machine implementation connects them to
actual models. Required methods prevent a missing device connection from
being silently interpreted as a successful hardware operation. [3, 9]
The native path explicitly fails if a machine host has not been installed. The Windows adapter instead forwards the contract to the existing implementation. Windows-specific printer handling was moved out of the PIA source into the Windows host. This is a targeted dependency inversion: the hardware model expresses the operation it requires, and the host supplies a platform-appropriate connection. It does not emulate Win32 functions through a universal substitute. [3, 9]
ROM provisioning illustrates the allocation and ownership
implications of the boundary. MmuInit validates the RAM
selection and prepares replacement RAM and ROM before replacing the
active allocation. The ROM provider receives a fixed-size destination
prefilled with $FF; file selection and validation belong to
the host. A failed allocation or provider operation preserves the
previously active memory, and repeated shutdown is supported. A
successful reinitialization or shutdown invalidates borrowed RAM and ROM
pointers, so consumers must not cache them beyond the corresponding
machine lifetime. The resulting contract makes failure behavior explicit
rather than allowing a file operation to partially replace machine
state. [3]
4.3. Rendering independent of window systems
The retained renderer computes pixels from emulated RAM and
video-register state. VideoState separates those data and
host-owned surface pointers from window-system handles, and
VideoHost supplies surface access, clearing, artifact-color
policy, active-area reporting, and frame-completion notification. The
Windows SystemState retains access to the extracted fields
through its adapter. The Mac path uses a 640 × 480 array of packed
32-bit 0x00RRGGBB values, with pitch measured in pixels.
The zero high byte is not transparency: the native display treats the
pixels as opaque. [4, 13]
The bridge publishes an owned image so that later execution, reset, or shutdown cannot mutate an already delivered frame. Metal presentation then handles drawable dimensions and display scaling. In the native boot implementation, each submitted GPU operation owns its upload texture; presentation may skip when the bounded in-flight submission capacity is occupied rather than blocking the main thread or overwriting an upload still in use. Presentation backpressure therefore affects which completed frames are displayed, not the machine's CPU-to-raster clock relationship. [5, 11]
Event lifetime is part of this separation. A scheduled renderer owns raster and timer event tags, cancels them when stopped, and uses lifetime guards so that abandoned callbacks cannot dereference a destroyed renderer. Reset must replace the old event set rather than layering a second raster schedule on top of it. Immediate debugger preview renderers do not acquire the live raster schedule. These rules support observation and reconfiguration without allowing an auxiliary image to become another authoritative machine clock. [4]
4.4. Bounded execution and authoritative emulated time
RunFrame is a synchronous core operation with four
relevant completion outcomes: completed frame, debugger halt, exhausted
work budget, or stalled processor. It repeatedly requests processor
execution, converts the returned unused-cycle count to actual progress,
and returns if that progress is nonpositive. A budget-limited partial
frame can be resumed; the function does not reset the raster, wait for a
window, flush audio, or pace wall-clock time. The final instruction may
overshoot the requested cycle budget according to the retained CPU
contract. [4, 12]
Separating bounded execution from pacing resolves an important ambiguity in graphical emulators. A host presentation callback is not an instruction clock, and a window resize is not a reset request. The native host decides when it is appropriate to request another bounded unit of work, while the core's event scheduler maintains the relationships among CPU execution, raster events, timers, and scheduled sample generation. Frame presentation intervals can omit host updates while guest devices continue to run. [1, 4, 5]
The audio path follows the same principle through a different host
constraint. Scheduled emulated events produce samples; an
AVAudioSourceNode callback drains a fixed-capacity
single-producer/single-consumer buffer. The callback does not enter the
emulator, allocate memory, acquire locks, or wait for the interface.
Device consumption supplies pacing feedback to the machine queue, which
refills a bounded reserve. Silent pacing is available when native output
is disabled or unavailable. This design accommodates the output device
without allowing its callback timing to rewrite guest clock ratios. The
reserve and missing-sample policy address host scheduling variability;
they are not claims of unlimited immunity to operating-system stalls.
[14]
4.5. Device objects and cartridge topology
Portable device objects replace Windows DLL loading in the native application. The FD-502 adaptation, for example, owns registers, transfer state, drives, images, and head positions while leaving host file dialogs and persistent-file operations outside the controller model. Device ownership is separate from an active slot assignment: disconnecting or moving a controller need not destroy its mounted image or discard modified bytes. Safe configuration changes still require the appropriate paused boundary and media checks. [1, 10]
The cartridge bus preserves topology rather than reducing the Multi-Pak to a menu of mutually exclusive devices. Its routing distinguishes the ROM slot from the disk-port slot, permits eligible active devices to receive the appropriate other-port traffic, advances devices on actual horizontal-sync callbacks, and retains the relevant interrupt behavior. The physical startup selector establishes reset routing; software register writes establish current routing. Persisting the startup selection does not serialize the current running program or turn runtime routing into a separate machine. [10]
This organization supports independent device testing, but it does not establish arbitrary multi-machine execution. Some adapted device models have isolated instance state while the CPU engines, scheduler, and host bindings remain process-wide. The architecture therefore makes a narrower promise: selected device implementations are independently testable, and one authoritative loaded machine coordinates their use within each process. [2, 5, 10]
4.6. Session ownership and the native bridge
MachineSession is the synchronous C++ owner of the
composed machine. An atomic occupancy claim permits one loaded session
and prevents a second session from replacing the first session's host
bindings. It is a lifecycle guard, not a lock around all emulator state.
Initialization, command execution, inspection, host replacement, and
destruction must still be serialized. Low-level core tests cannot safely
run concurrently with a loaded session in the same process. [5]
The native VCCMachineController enforces the
corresponding application rule through a private serial dispatch queue.
User-interface commands and execution callbacks enter that queue, and
completion handlers carry owned snapshots to the main queue. The
interface does not dereference live core pointers. A snapshot can
therefore include CPU and run state, configuration, frame and cycle
counters, generation and program identities, and an immutable completed
frame without requiring a view to understand the internal emulator locks
or global variables. [5, 15]
Lifecycle operations have distinct semantics. Pause stops further execution without replacing the loaded machine. Cold reset reconstructs the machine from retained configuration and ROM, while soft reset follows the retained warm-reset sequence and preserves RAM at its boundary. Both reset paths advance identities used to distinguish old observations from the new timeline. Synchronous session shutdown is idempotent and permits a later load, whereas bridge shutdown is terminal: delayed queued work cannot restart a bridge after application teardown. This distinction makes ownership visible across the language boundary. [5]
Compile-time checks make the retained register layout and integer-width assumptions explicit at the host boundary. Complete reentrancy, big-endian support, exhaustive aliasing review, all historical Windows devices, and complete Windows/Mac trace parity are outside the demonstrated boundary. The result is a selected shared engine with explicit host contracts and a native integration, providing a basis for the richer observation and development services examined in the following sections. [1, 2]
5. Runtime Observability and Debugging Services
I used the extracted core as the foundation for the new debugging tools. Consistent observation also required an explicit state boundary. A debugger must also determine which machine state it observed, whether a memory read changes hardware behavior, and whether its interpretation remains applicable after execution or mapping changes. VCC Plus addresses these requirements through a set of services distributed across the shared C++ session, native bridge, and development models. Their common design principle is that a visible value or source association must be supported by a specific captured state and an identified program. [16, 17]
5.1. Consistent observations at a serialized execution boundary
The session owns execution and inspection on one serial queue. A debugger request captures registers, execution counters, run state, effective mapping, and selected memory before another machine command is allowed to interleave. The resulting buffers are owned by the observation rather than borrowed from mutable emulator allocations. Native views consume these observations through the Objective-C++ bridge; they do not dereference the running core. This discipline prevents a display of registers from one instruction boundary alongside memory from a later boundary, and allows an inspector to retain an observation across subsequent execution or reset. It does not make the legacy global state reentrant; its validity depends on the serialized owner described in Section 4. [16]
The distinction between a consistent observation and a complete history is important. A snapshot describes one boundary. Selecting an older caller in a call-stack view changes how the same captured state is interpreted; it does not recover the memory that existed when that caller originally invoked its callee. A pointed-to object or global may therefore contain modifications made by the current callee. Historical execution is provided separately through retained trace records, not inferred from current memory. [17]
The main application and auxiliary tools share the same machine authority. Polling transports observations without giving views ownership of execution or media operations. A delayed refresh cannot redefine guest time, and closing an inspector does not undo an armed machine operation. [16, 18]
5.2. Side-effect-free logical and physical memory inspection
Memory-mapped I/O makes an ordinary emulated read unsuitable as a
universal debugger primitive. A read can acknowledge a PIA interrupt,
consume a device datum, or otherwise alter the state being examined. The
inspection services consequently distinguish accessible memory from
locations whose value cannot be obtained safely.
MachineSession::debuggerSnapshot associates each logical
byte with an availability flag. Its safe path includes ordinary memory,
a non-destructive GIME register view, and system-vector reads; other I/O
locations remain unavailable. A placeholder byte in the transport is not
a claimed device value. [16]
Physical inspection is a separate operation. It reads installed RAM without mapping it into the CPU address space and without substituting ROM or device values. This supports examination of banks hidden by overlays or inactive MMU tasks. The debugger reports the effective backing selected by the core, including special vector windows and mirroring, rather than attempting to derive every result from the displayed register values. Logical and physical addresses therefore remain distinct even when their numeric values happen to agree. [18, 19]
The APIs deliberately impose different range contracts. The snapshot service can capture a bounded logical view with 16-bit wrapping semantics, whereas explicit memory-range capture rejects wrapping or overflowing ranges. Physical snapshot requests are limited and truncate at installed-RAM bounds; explicit range exports require the complete selected range to be valid. These contracts are stated separately because silently applying one address-space convention to another would produce misleading dumps. A mapped export containing unavailable I/O fails rather than replacing unknown values with zeros. [16, 19]
Writes remain explicit debugger operations with their own preflight. The conservative RAM-edit path validates an entire bounded span before modifying it and excludes I/O, ROM, and unsupported high-memory regions. Observation services never acquire write authority merely because an inspector can display a corresponding address. This separation also makes it possible to expose a narrower external inspection interface without exposing native memory editing. [16, 20]
5.3. Program identity and rejection of stale commands
A logical address is not a durable identity for source code. Reset can replace the machine timeline, a load can replace executable bytes, a debugger edit can invalidate the retained build, and MMU changes can select different RAM at the same address. VCC Plus carries several distinct identities to represent these changes. Machine generation identifies lifecycle changes; program revision identifies explicit code replacement or editing; the mapping fingerprint summarizes the effective CPU address space; expected instruction bytes connect source associations to actual code. The program counter identifies the execution point within that combination. [16, 17]
A source-step request supplies the expected generation, program revision, mapping fingerprint, and PC. The session rechecks those facts on the execution queue before accepting the request. The instruction set supplied for a step must also be bounded, nonoverlapping within its declared module, and consistent with verified executable evidence. Failure of any precondition results in an explained refusal instead of execution against a plausible but obsolete source map. For flat programs, unexpected effective-mapping changes invalidate the step; declared banked programs use module-aware rules described in Section 6. [16, 17]
These identities establish a conditional association between captured state and retained code. They do not authenticate third-party programs or formally prove hardware state. A previously successful compilation cannot by itself authorize interpretation of later RAM. [17, 20]
5.4. Controlled execution with finite work
The bounded frame runner returns on a completed frame, debugger halt, exhausted cycle budget, or lack of CPU progress. A partial frame can resume without restarting the raster. This makes a debugger stop an ordinary execution result, rather than a condition that can strand a host loop waiting for a frame that will never complete. The final instruction may exceed a nominal cycle budget because the engine preserves its instruction-execution contract; the budget limits further work, not the indivisibility of an already started instruction. [16]
Source stepping builds on normal guest execution instead of simulating source-language statements in the host. Step Into seeks the next mapped line, Over follows the current call without suppressing explicit breakpoints, and Out follows the supported return path. Interrupt handling continues through the ordinary engine. Independent instruction, frame, and depth limits prevent an input wait, nonreturning subroutine, or malformed control flow from becoming an unbounded UI command. A user pause cancels the pending step. A limit-induced pause reports its actual reason rather than inventing a source statement at an arbitrary mid-operation location. [17]
Instruction stepping retains meaningful processor-specific behavior. An HD6309 TFM block transfer can span many internal transfer iterations and raster boundaries. The explicit instruction-step operation completes the instruction while device time continues to advance, and frame-completion accounting records actual boundaries. Normal continuation and tracing retain the engine's transfer-byte behavior. The different granularity is reported rather than flattened into a misleading universal definition of a step. [18]
5.5. Historical instruction and hardware-event tracing
The trace service retains pre-execution instruction bytes, before/after CPU registers, instruction-cycle information, and optional hardware or scheduler events. It does not reconstruct past instructions by reading current RAM. Consequently, self-modifying code, later MMU changes, or debugger edits cannot rewrite an already captured row. A trace that reaches its configured bound stops recording while leaving guest execution in its current run state. Triggering a trace and setting a breakpoint are separate operations: a stop-before trace trigger ends recording before the identified instruction but does not itself prevent that instruction from executing. [21]
Interrupt requests, servicing, and vector-entry events come from the corresponding CPU hooks. These are distinct observations: an asserted request does not prove that the processor accepted it. HSYNC, VSYNC, and video-register rows likewise originate in the renderer and register hooks. The implementation does not infer missing events from plausible register values, and it does not recreate the old Windows scheduler's private variables as if those variables were native events. [21]
Rows use an emulated master-clock timeline, with instruction cycles retained as a separate quantity. A 263-line raster with 912 master clocks per line yields a nominal frame period of 239,856 master clocks in the retained model. This permits comparisons across ordinary guest CPU speed changes without confusing CPU cycles, video fields, and wall-clock time. It is not a measurement of display latency or host scheduling performance. [21]
Capture is finite, up to 100,000 combined instruction and event rows in the documented interface. The viewer retrieves immutable pages, and export copies a selected range before performing formatting away from the machine queue. Reset stops recording while retaining collected samples; replacement of the machine clears the old capture. These rules make lifecycle boundaries visible and prevent a growing trace or a slow save operation from becoming an implicit owner of the emulator. [21]
5.6. Graphics inspection as a memory service
The displayed framebuffer is useful evidence of what the renderer completed, but it is not sufficient to inspect a drawing buffer that the guest has not yet displayed. VCC Plus therefore provides a graphics-memory interpretation service in addition to normal frame delivery. It can inspect the current video page or render an explicitly selected logical or physical memory range using the supported text, semigraphics, PMODE, and HSCREEN interpretations. Pixel inspection connects a visible coordinate to its stored byte, address, and bit mask. Attributed text also exposes the attribute byte. [19]
The preview does not advance the raster or change the guest's displayed page. Logical and physical origins remain explicit, unavailable I/O is marked, and declared custom GIME canvases preserve relevant scrolling and row-stride information. A paused paired capture can describe the displayed buffer and one manifest-declared buffer from the same state, which is useful for diagnosing double buffering without changing the program to expose its hidden page. A decoded pixel color is an interpretation of captured memory and video state; composite artifact colors may depend on neighboring bits. [19, 22]
The related disassembler also operates on captured bytes. Physical disassembly accepts an assumed logical origin for relative branches without actually mapping the selected RAM. Optional OS-9 interpretation annotates recognized calls and module headers, but it does not assert that every numeric service exists in the running OS or that a header has a valid complete module CRC. These tools preserve the distinction between a useful annotation and a validated guest object. [19]
6. Language-Aware Debugging and Toolchain Extensions
I start from the bytes and registers obtained through machine inspection. Source debugging requires a further chain of interpretation: source text must correspond to compiler output, compiler output must correspond to the linked artifact, and the artifact must correspond to the code currently mapped in RAM. VCC Plus implements this chain in native development services using core observation and execution primitives. These services are part of the overall platform, but their source parser, metadata interpreter, and UI are not represented as features of the CPU engines themselves. [17, 20]
6.1. Source maps anchored to executable evidence
CMOCSourceMap and its project-level companions associate
source lines with final instruction bytes. The verifier checks source
snapshots, listings, objects, linker placements, and executable
artifacts rather than accepting a listing address in isolation.
Supported object relocations are replayed against the selected section
bases and compared with the delivered initialized bytes. Missing or
ambiguous symbols, invalid relocation expressions, overlap, and
incompatible listing bytes fail verification. The resulting source map
therefore identifies the bytes after linking, including operands whose
values differ from the unresolved object listing. [23]
The build receipt exposes this distinction directly. A successful compiler or Make process does not necessarily produce usable debugging evidence. The documented statuses distinguish an executable/source association with usable typed metadata, an executable/source association without that metadata, and unavailable debugging with an explanation. A source declaration, a mapped C statement, and a verified executable entry are also separate catalog entries. This avoids presenting an assembly entry or a function declaration line as if it were a currently executing C statement. [20]
For optimized programs, executable symbols can remain useful even when local variables or statement mappings are unavailable. Named symbol-entry stops permit inspection of verified code without manufacturing a C frame or source location. The service selects advertised unique identities rather than accepting an arbitrary address through the external interface. Native manual address breakpoints retain their separate role. [20, 22]
6.2. Compiler metadata for types, scopes, and storage
The CMOC extension emits versioned VCCDBG1 records from
the compiler's resolved declarations and types. The records describe
function entry, frame-ready body, and epilogue boundaries; lexical
scopes; signedness and storage widths; arrays, members, pointers, and
floating encodings; linker-resolved global storage; and U-relative
parameter/local locations. Zero-byte assembler labels anchor ranges
without adding instructions or data. [24]
The metadata is an additional evidence source, not authority by itself. The application resolves its symbols through objects and matching linker placement and accepts it only within the retained build identity. Ordinary release compiler invocations omit these debug labels and records. Debug labels can affect optimization opportunities even though they occupy no bytes, so the project does not claim that enabling source debugging is semantically identical to every optimized build. Supported local inspection requires an appropriate unoptimized build with the preserved frame convention. [17, 24]
6.3. Conservative call stacks and typed values
The native C unwinder supports ordinary CMOC calls with a preserved U frame. It verifies the relevant prologue/epilogue convention, readable frame links, source scope, and the direct call instruction associated with a saved return address. It does not scan arbitrary stack words for addresses that happen to resemble code. An unsupported interrupt, assembly, optimized, indirect-call, or unmapped boundary terminates reconstruction with a reason. Thus a partial stack denotes the verified suffix of a call chain, not proof that its oldest displayed function is the program root. [17, 25]
Caller selection is an observation operation. It changes the source location and scope used by Variables and Watches, while stepping continues from the real leaf execution point. Registers, cycles, PC, and memory are not restored to the selected caller. This rule avoids a common ambiguity in source debuggers: the selected frame is a view context, not a second execution cursor. [17]
Typed values are decoded from one paused memory capture using compiler-provided storage and scope. Arrays and aggregates are paged and bounded; pointer expansion is explicit, pointer cycles terminate, and unsupported children do not invalidate readable siblings. A pointer value does not establish an allocation length or the continued lifetime of an object. The watch evaluator supports read-only integer expressions and selected address/member/index operations without running guest functions, assignments, getters, or hardware reads. Its calculated arithmetic uses checked 64-bit host integers, a documented inspection language rather than a claim to reproduce CMOC's complete target promotion and overflow rules. [17]
Stored floating-point inspection depends on explicit encoding metadata. The implementation supports the CoCo BASIC five-byte representation and big-endian IEEE binary32 selected by the applicable compiler option. It does not infer a format merely from a type name, current ROM, or byte count. Missing and inconsistent metadata leave the value unavailable. Decimal formatting exposes the stored approximation; displaying more digits than a familiar rounded literal can therefore reveal representation rather than an arithmetic failure. Floating-point expressions remain outside the integer watch evaluator, and decoding does not invoke a guest math runtime or imply that an optional runtime has been executed. [17, 24]
6.4. Banked and packed executable identity
Banked programs require a stronger identity than the pair of source file and logical address. A loader, resident function, or alternate overlay can present the same opcode at the same CPU location while referring to different physical storage. The banked manifest binds a delivered binary and disk to source hashes, object/listing evidence, linker sections, unpacked module bytes, and explicit logical-to-physical page assignments. Actual physical backing is checked after hardware mirroring; a written MMU register value alone is not the final identity. [22, 26]
Executable sections have complete byte guards, including assembly outside mapped C lines. Mutable data and BSS retain section ownership but are not falsely required to remain equal to their load-time values. Modules that reuse logical addresses must have distinguishable physical ownership, and ambiguous simultaneous claims are rejected. The application independently replays supported object relocations and checks live code instead of treating the manifest's hashes as self-proving declarations. [22, 26]
A disk-source attachment does not install the program by altering RAM, PC, or banks. Normal guest loading establishes the program; a source stop becomes eligible when its own module is mapped and its complete code matches. Expected declared bank transitions can preserve the attachment, while wrong-page selection or changed code makes the corresponding source interpretation unavailable. The debugger does not remap hidden storage to retrieve a global. This preserves the program's execution context while permitting useful inspection of overlays as they become active. [17, 22]
6.5. Interpreter-aware BASIC services
BASIC debugging follows a different contract from compiled C.
BasicProgram and the session services recognize a qualified
interpreter and memory layout, tokenize editor source, and retain source
associations for the tokenized program. Load and Run validate the entire
replacement against interpreter state, mapping, program space, and
source constraints before writing program memory. They operate through
the existing ROM interpreter and retain mounted media and machine
configuration. Continue is explicitly distinct from Run: it resumes the
existing program without clearing variables or GOSUB/FOR state. [27]
Line-entry breakpoints use a validated interpreter dispatch point and source/program correspondence. Statement stepping can identify separate statements on a colon-separated line and distinguish dispatched THEN/ELSE commands. Over and Out track supported GOSUB behavior, including recursion, without mistaking FOR/NEXT records for subroutine frames. Explicit breakpoints take precedence, and a finite emulated-frame limit prevents INPUT waits or nonreturning subroutines from monopolizing a command. Runtime errors and normal returns to the prompt terminate the corresponding operation with an appropriate location or status. [27]
Tokenization records positions in the editor's original source so a highlight can preserve spelling, spacing, and line-ending conventions. Reading a listing back from guest memory is a different operation and produces a canonical representation. Source edits detach obsolete execution associations, and runtime changes to line links, dispatcher identity, or relevant mapping likewise invalidate the attachment. Unknown ROMs, arbitrary cartridges, and OS-9 are not accepted merely because an address resembles a known BASIC workspace. These restrictions make the interpreter-specific facility useful without claiming a universal BASIC debugger. [27]
The historical interpreter documentation supplies an independent
description of the underlying mechanism. Color BASIC Unravelled
II identifies the linked tokenized-line format and the dispatcher
at $ADC6, including CURLIN at
$0068 and the CHARAD word at
$00A6; its GOSUB/RETURN listing documents the interpreter
state retained across a subroutine. The Extended and Disk BASIC
disassemblies show their separate entry paths calling the common
dispatcher. These edition-specific references explain the hook design;
runtime qualification of a particular ROM remains a project
responsibility. [74, 75, 76]
6.6. Assembly workflows and guest-facing libraries
The assembly workspace reuses the machine's instruction debugging and executable guards while providing native source documents, assembler output, source associations, processor checks, and binary or Disk BASIC export. It does not require a separate emulation state. A changed source project is rechecked before continuing with its retained associations, and entry debugging operates on the loaded program identity. This establishes a direct workflow for code whose meaning cannot be represented honestly as C statements. [28]
The guest SDK extends the development platform in another direction. Libraries expose reviewed CoCo operations for GIME graphics, banked transfers, joystick input, Speech/Sound, Orchestra-90, SDC, printer, and cassette, together with a bounded C compatibility subset. These execute as guest software using the modeled hardware and supported ROM services; they are not general privileged shortcuts from a guest program into native host memory. Original VCC Plus libraries and unchanged third-party libraries retain distinct provenance and terms. Their examples also provide integration workloads that connect compiler output with real device paths, but successful SDK use does not establish exhaustive emulation fidelity. [29]
6.6.1. Banked assets and restoration of machine context
The bank library provides a copy-oriented interface to an explicitly reserved 32 KiB asset region, physical pages $28–$2B ($50000–$57FFF). A caller supplies an ordinary C buffer and an offset within this region rather than retaining a pointer into a temporarily mapped bank. This distinction matters because a 16-bit guest address identifies the currently selected CPU mapping, not a permanent location in expanded physical RAM. The library accepts only a supported stock CoCo 3 BASIC task-0 environment, at least 512 KiB of RAM, and a normal CMOC code, data, and stack layout below $8000. Opening and closing reserve and release the library's use of the region without clearing its contents. They do not constitute a general physical-memory allocator. [41]
Before a transfer, the implementation validates the complete bank range and the complete caller buffer. Subtraction-based bounds checks avoid accepting a wrapped offset-plus-length expression. Read destinations must be writable data; write sources may include constant program data. A zero-length operation needs no buffer and can name the end of the reserved region. Unsupported mappings and overlapping use of the reserved physical pages are refused before copying. The opening probe also checks that candidate high-memory pages are independent of ordinary low memory, so a configuration in which nominal extended pages alias a smaller RAM installation is not accepted merely because an MMU register can be written. On expanded machines the documented BASIC bank and prefix settings must remain in force: write-only state cannot be recovered reliably after arbitrary application paging. [41]
Transfers are divided at physical page boundaries and into chunks of at most 32 bytes. Each chunk saves the condition-code register and affected MMU mapping, masks IRQ and FIRQ, maps the selected page into the copy window, performs the short copy, restores the mapping, and finally restores the original condition codes. Restoration therefore preserves a caller's existing interrupt mask rather than unconditionally enabling interrupts. The normal mapping is available between chunks. This provides a concrete upper bound on the copy work inside one masked interval, although it is not a complete bound on application interrupt latency. The authored qualification sources examine physical bytes, page-boundary transfers, rejected ranges and configurations, and mapping restoration for both emulated processors. Inspection of these fixtures identifies the intended regression coverage; dated execution is reported separately. [41, 48]
6.6.2. GIME drawing and bounded presentation
The graphics library implements a specific double-buffered GIME mode: 320 × 192 pixels with 16 colors, packed two pixels per byte. Each image uses 30,720 bytes within a 32 KiB region; the two regions occupy physical $40000–$4FFFF. These pages are disjoint from the bank library's asset region. The public interface requires an ordinary IRQ-enabled BASIC text environment, stock MMU task 0 and video-RAM grouping, sufficient RAM, and the program and stack below $8000. Opening rejects unsupported configurations and clears both image pages. It is not a facility for adopting arbitrary pre-existing graphics-register state. [42]
Drawing changes the hidden image. Rectangle clipping uses the remaining width and height, and packed-pixel edge writes retain the adjacent pixel's nibble. The implementation restores MMU and interrupt state around mapped drawing spans and permits IRQ service between rows. A page remains intact when it later becomes hidden, allowing incremental redraws if the caller accounts for its previous contents. Palette changes are immediate and shared by the displayed and hidden images; the term double buffering applies to pixel storage, not to a second independently staged palette. [42]
Presentation waits for a change in BASIC's complete 16-bit field timer while leaving IRQ service enabled. The polling loop has a finite $2000-iteration limit. Once a change is observed, one high-offset register write selects the aligned finished page, and only a successful presentation exchanges the visible and drawing identities. Failure to observe timer progress returns failure without exchanging them. Comparing the timer for inequality also permits its ordinary wraparound. This is a bounded synchronization protocol dependent on the supported BASIC vertical-interrupt service; it is not evidence of universally tear-free output under arbitrary interrupt replacement or delay. Closing restores the saved palette and the supported BASIC text-register image, including when the field wait fails. Because several video registers are write-only, the restoration contract is deliberately limited to known BASIC text states. The public fixtures include page-content and raster observations, clipping and guard-pixel checks, timeout behavior, and restoration checks. [42, 48]
6.6.3. Background Orchestra-90 and shared interrupt resources
Orchestra-90 support separates direct DAC writes, blocking foreground playback, and an asynchronous player. Each stereo frame contains one unsigned byte per DAC. The foreground player leaves the declared guest clock, timers, and interrupt masks unchanged; interrupt handling can delay its approximately 4,000-frame-per-second output. The background player instead borrows a specific set of resources in a stock CoCo 3 BASIC environment: the BASIC IRQ trampoline, an otherwise unused PIA horizontal-interrupt source, the two DACs, and the guest clock setting. It refuses an unsupported trampoline, a busy horizontal-interrupt source, disabled required interrupts, or another active playback session. Since the DACs are write-only and have no reliable device identifier, a successful start establishes that the supported setup was accepted, not that a physical cartridge has been detected. [43]
The background routine returns to foreground code and services one stereo frame per four serviced scanlines, approximately 3,930 frames per second at NTSC timing. It selects the fast guest clock for playback and delays sample output until the second genuine BASIC vertical interrupt, allowing that transition to settle. The normal vertical-interrupt handler continues to run, preserving BASIC timer and keyboard activity. The GIME timer and FIRQ vector are left available. The handler uses resident private state without assuming the foreground direct-page register, but the application must keep the handler, sample array, stack, and their mappings valid until playback ends. Completion of a one-shot, or an explicit stop, releases the borrowed interrupt resources, restores the declared prior clock setting, and rests the DACs at midpoint 128. Cleanup preserves the current unrelated PIA multiplexer selection rather than restoring an obsolete whole-register image. [43]
This resource discipline supports cooperation with foreground work; it does not implement a general interrupt-arbitration system. Long interrupt masks and PIA reads can delay service. The bank library's short masked copies and the graphics library's row-wise mapping restoration reduce particular sources of interference, but they do not establish a zero-jitter composition theorem for all three libraries. A combined workload must be measured with its actual drawing, input, and asset-transfer schedule. The authored background-audio fixtures exercise refusal without disturbing caller state, repeated and one-shot playback, release of resources, preservation of foreground PIA changes, and DAC sequences under both emulated processors. Such tests support the stated protocol, not a claim of exact sample timing on every host or physical machine. [41, 42, 43, 48]
6.6.4. Sampled input and observable state changes
The input adapter exposes one caller-owned state record per joystick port. A sample contains six-bit X and Y coordinates, thresholded directions with an explicit neutral band, and held, newly pressed, and newly released button bits. Initialization samples a baseline: a button already held is reported as held, without inventing a press transition. Subsequent transitions compare successive samples. A complete press and release between two samples is consequently unobservable. The API is a foreground sampling interface, not a lossless host-event queue, and a game's update cadence determines its attainable input responsiveness. [44]
Axis acquisition uses successive approximation against the six-bit DAC and the CoCo analog joystick circuit, building on BControl's multiplexer and button operations. The short PIA transaction saves and restores the sound gate, multiplexer selection, DAC output, keyboard-column output, and original interrupt mask. These restorations prevent polling from persistently changing a foreground sound selection or keyboard-column configuration. They cannot undo all effects of observation: ordinary PIA data-register reads can acknowledge interrupt flags. Thus this guest API has materially different semantics from the debugger's side-effect-free inspection services. When background horizontal-interrupt audio is active, sampling can also delay an audio service opportunity. Foreground block audio permits sampling between blocks, with block size determining an additional latency tradeoff. These limits should remain explicit when the library is used as an emulator integration workload. [43, 44]
6.6.5. A bounded C compatibility subset
The compatibility layer makes selected C idioms available within the guest's memory and Disk BASIC environment. Its headers are opt-in and enumerate the supported operations rather than promising a complete hosted ISO C implementation. Bounded formatting supports character and string conversions, signed and unsigned integer conversions, octal and hexadecimal forms, integer long modifiers, field width, alignment, padding, and string or integer precision. A positive output capacity always leaves a terminated prefix; a zero-capacity call permits a null output pointer and computes the required length. Unsupported formats and lengths exceeding INT_MAX return failure. Floating-point formatting is outside this subset, and overlapping input and output remain unsupported. The distinction between a full required length and the number of stored bytes makes truncation observable to the caller. [45]
File streams operate on guest Disk BASIC files through the ordinary ROM-backed decbfile interface. They do not open arbitrary host paths. Two foreground streams, each with a 256-byte buffer, support documented 8.3 names, drive suffixes, read/write/append modes, binary selection, and update modes. Complete granule-chain validation rejects malformed bounds or loops before exposing file data. Text reads normalize CR, LF, and CRLF to a C newline, while text writes use the guest's CR convention; binary access retains byte values. The wrapper saves and restores decbfile's active disk-service pointers around synchronous ROM operations instead of treating each call as permission to reinitialize another user's library state. A compatible Disk BASIC ROM remains an external runtime prerequisite; its code is not supplied by this adapter. [45]
Buffering introduces a second completion boundary. Acceptance by a write function does not imply that every later disk operation has succeeded. Callers must inspect flush and close results. A successful flush publishes the current file data and exact length so a newly opened reader can observe the checkpoint while the writer remains open; an already opened reader retains its recorded length. Update streams enforce transitions between reading and writing, and append writes target the end even after a seek. Mounted media and alternative disk APIs must remain stable until streams are closed. These contracts define guest file visibility; they do not independently establish host crash durability or remove the emulator's write-protection, media-saving, and recovery obligations. [45]
Allocation is similarly explicit. The caller supplies a fixed writable guest array of at least 16 bytes whose extent does not wrap the address space. Reinitialization while allocations remain live is rejected. The wrapper uses WydeAlloc and retains its own allocation-size prefix rather than depending on that allocator's private block representation. Zero-size allocation returns null, calloc checks multiplication overflow, and failed realloc growth leaves the original allocation valid. Shrinking retains the block; realloc with zero size releases it. These are useful bounded failure semantics on a small machine, not host-backed virtual memory or protection against freeing arbitrary invalid pointers. [45]
The composition preserves upstream authorship. CMOC is Pierre Sarrazin's compiler; the input adapter uses his BControl library, ROM-backed disk services use decbfile, and allocation builds on WydeAlloc. The manifests distinguish public-domain library components from GPL-covered components, and LWTools retains William Astle's attribution and terms. VCC Plus's original wrappers and hardware libraries do not subsume those licenses or transfer authorship of the underlying work. Compatibility fixtures and guest-running stream, write, input, and heap tests supply inspectable examples of success, refusal, and recovery. Their presence is source evidence of intended coverage; dated qualification records identify which configurations were actually executed. [37, 44, 45, 48]
6.7. Bounded call context for owned paused runs
The call-context extension exposes a deliberately limited diagnostic
view for a verified, paused, owned C playtest.
get_call_context accepts the run and immutable snapshot
identifiers; it has no caller-selected address, length, or expression.
The new disclosure is exactly 64 bytes beginning at the actual stack
register S, accompanied by byte values, big-endian word views, and the
physical RAM spans backing the window. Every byte must be available RAM
below the protected high-memory boundary. ROM-backed, unavailable,
wrapping, or unverified locations produce an unavailable result. [30]
The raw window is explicitly uninterpreted. A stack word may represent a register, local, padding, or an argument. Availability of the raw view therefore does not imply availability of a caller or typed values. Caller interpretation requires matching compiler metadata and verified ordinary CMOC prologue/epilogue bytes. At exact entry, the candidate return address is the two bytes at S; in a mapped body, the supported saved-return slot is U+2 and must remain wholly inside the same window. The candidate must match one unique verified direct call to the current callee in approved caller source. There is no search for plausible return addresses or assumption about indirect, interrupt, tail, or unfamiliar calls. [30]
Integer arguments require additional compiler location evidence, a supported frame, a verified caller, nonoverlapping named storage, and complete containment within the same window. Unsupported types, pointers, aggregates, out-of-window values, and optimized or unknown frames remain unavailable. Even the count of available parameter records does not claim that metadata contains the complete runtime prototype. No pointer is dereferenced to enlarge the disclosure. The window is not added to the ordinary external memory-read ranges. [30]
The service rechecks connection, project, artifact, worker, boot, processor and execution mode, registers, mapping, program revision, counters, memory, and availability against the selected immutable pause. Execution, a new snapshot, media exchange, source/build replacement, restart, or revocation invalidates the applicable observation. Its external grant is specific to the C owned-playtest capability; older grants, ordinary shared runs, BASIC, and assembly connections do not inherit it. This provides a useful raw diagnostic for optimized code while keeping evidence-dependent ABI interpretation separate from what the bytes alone establish. [30]
6.8. Compiler Correctness and Toolchain Engineering
I treat the compiler as a second boundary for executable behavior within the development platform. A correctly emulated register can still supply an incorrect application result if a compiler transformation changes an effective address or discards a condition code on which generated code depends. VCC Plus therefore maintains targeted CMOC 0.1.100 corrections in addition to its debugging metadata extension. These corrections address general optimizer rules, not recognition of a particular game, variable name, or peripheral API. Their separation from emulator changes is essential to diagnosing the layer responsible for a failure. [34, 35]
6.8.1. Indexed arithmetic and hidden register dependencies
The MC6809 register model creates dependencies that are easy to miss
in an assembly peephole transformation. Register B is the low byte of D.
An instruction that appears merely to replace a byte value can
consequently change the effective address of a later B,X or
D,X operand, including indirect addressing. Similarly,
removing a stack push changes the interpretation of subsequent
S-relative operands, and removing a predecrement or postincrement
operation changes state beyond its loaded value.
The indexed-byte subtraction patch guards three transformation sites
in ASMText2.cpp. Reordering two loads for a comparison is
refused when their addresses depend on B, S, or an index-update side
effect. Rewriting subtraction through negation and addition is refused
when changing B before a load would change that load's address, or when
removing the push changes its stack-relative operand. A further
operand-swap rule rejects B-dependent addresses. Safe immediate and
independent cases remain eligible for their existing transformations;
the correction constrains the conditions under which a rewrite is
justified. [34]
The authored regression includes 184 - heights[i],
runtime word and byte indices, variable pointer bases,
conversion-induced byte wrapping, both operand orders, and comparisons
against an indexed byte. It prints raw result bytes for comparison with
independently calculated host expectations. This structure matters
because a guest-side assertion implemented using the same defective
subtraction or comparison could mask the failure it was intended to
detect. The fixture tests emitted program behavior rather than merely
checking whether the optimizer recognizes a particular source spelling.
[34]
6.8.2. Indexed function arguments and effective-address evaluation
A second failure arose while a joystick-driven program passed adjacent axis and calibration values to a function. The optimizer removed a load whose value appeared to be overwritten, leaving the prior argument's value to select the next array element. The relevant sequence was:
LDB index
LDX #centers
LDB D,XAlthough the final instruction writes B, it first reads D to compute its effective address. The initial B load is therefore live at that instruction. Looking only at the destination register mistakes an address dependency for a dead value. The original rule also inspected the mnemonic field where it needed to examine an operand for index-update side effects. [35]
The correction uses CMOC's existing instruction-effects analysis to
test B dependencies in both the intervening X load and the final B load.
This includes D-indexed and indirect forms rather than a single literal
B, prefix. It separately checks whether removal of the
first load would discard a predecrement or postincrement effect.
Independent overwritten loads can still be removed. The change repairs a
compiler rule without changing the emulator's joystick values or the
guest program to accommodate the defect. [34, 35]
The retained qualification record documents a useful before/after
discriminator. The earlier staged compiler passed at -O0 on
both guest processors but failed at -O2. For one pair of
indices, the expected bytes were 04 0C 08 10 14 1C 18 20;
the defective byte-index case instead produced
04 0C 3A 10 14 1C 3A 20. The deliberately distinct
$3A sentinel identifies use of an unintended array element.
The corrected compiler's documented matrix passed through both host
compiler slices, at both optimization levels and on both guest
processors. A direct rule fixture separately checks thirteen
dependency/side-effect guards and two safe removals. These historical
observations are distinct from the fresh paper-specific matrix in
Section 9.7. [35]
6.8.3. Logical negation and condition-code liveness
The add-zero correction addresses another implicit output of an
instruction: its flags. CMOC can emit ADDD #0 to establish
a word-sized zero test. Numerically, adding zero leaves D unchanged, but
removing that instruction can leave a stale Z flag for a following
runtime helper. The recorded example returns one in D while Z remains
set from clearing A. Removing the add before tfrZtoB then
makes !getReady() produce one, although the function
returned a nonzero integer. An identity transformation on the arithmetic
value was not an identity transformation on the observable machine
state. [34]
The patch removes unproven add-zero deletion and byte-test substitutions from the general peephole rule. More specific transformations for recognized load/compare/branch sequences remain in place. This is a conservative repair to the rule's proof obligation, not a general disablement of optimization. The corresponding C fixture prints results for zero, widened unsigned-byte values, and 16-bit values with only either half or both halves set. Expected results are supplied by the host runner. Together with the indexed cases, it demonstrates that compiler correctness requires accounting for address registers, stack effects, and condition codes in addition to explicit destination values. [34]
6.8.4. Source identity and scoped preprocessing
The dependency-path correction preserves filenames through generated Make prerequisites and preprocessor line markers, including quoted or escaped spaces, dollar signs and hashes. This prevents a valid source file from acquiring a different dependency identity merely because its host pathname requires escaping. [36, 37]
The native mcpp adapter expands ordinary C normally but processes
balanced inline-assembly bodies in assembler mode. It substitutes only
those bodies, preserving operands such as #COUNT and
-COUNT,x without changing C token boundaries, strings or
preprocessing errors elsewhere. Matching block counts and retained line
markers are prerequisites; inconsistent transformations fail rather than
compiling truncated input. [36]
6.8.5. Tool extensions and executable identity
Two accompanying changes extend other tools rather than CMOC's
optimizer. LWASM's project-input and source-map extension bounds
assembly-workspace reads and records physical source associations for
verification. The writecocofile extension exposes a forward
disk-allocation policy needed by the unmodified CoCo Letters recipe:
allocation starts at granule zero, skips occupied granules and can
continue beyond the directory region. Its
--allocate-before-dir name does not impose a strict
below-directory limit. These contracts identify what changed without
attributing the assembler, filesystem implementation or guest libraries
to the compiler corrections. [38]
Tool identity must also survive an unchanged upstream version string. Feature markers and payload hashes bind a retained artifact to the corrected compiler actually used; a source patch alone cannot establish that a running debugger is interpreting output from that compiler. A recorded source/staged-binary mismatch illustrates why the executable participates in the evidence chain. [37, 39]
The optimization study in Section 9.8 supports retaining
-O2 for ordinary Release projects while making
frame-pointer omission an explicit choice. The preserved Debug frame
supplies the storage and caller conventions required by the supported
source debugger. The measured tradeoff concerns build settings in the
corrected compiler, not a speedup attributed to these patches. [40]
7. Reproducible Development and Programmable Testing
7.1. Source-to-artifact identity
CMOCProjectInputManifest gives source interpretation a
content-based identity spanning approved source, headers, resources,
generator prerequisites, support roots and relevant control permissions.
The same classification governs navigation, build snapshots and
external-tool scope. Generated source can be a real input; declared
products and diagnostic outputs must remain outside that identity so a
build does not invalidate itself. Modification time alone cannot
distinguish a source change from a scheduling change. [31]
Input scope is path-bounded. A discovered dependency cannot grant access to another root, and an approved support folder cannot recursively enlarge that scope through its own settings. Changes to included content or toolchain payload invalidate the affected artifact and owned execution. Replacing a compiler under the same version string therefore cannot silently reuse results from its predecessor. Isolated working copies preserve the user's project when cache verification fails. [29, 31]
The artifact receipt separates process completion from evidence validity. A zero Make exit status can coexist with rejected executable or debugging metadata; a preparation failure can have no process exit code. Retained diagnostics report these outcomes directly, so an external client cannot mistake a successful command for a verified program association. [20]
7.2. Refresh without erasing editor work
Editor text, filesystem contents and a retained executable can represent three different program states. Refresh updates clean inputs while preserving drafts; a conflict with a draft's saved base requires resolution. Changes to input scope or execution permissions require review and identity rechecking before adoption. Refresh alone neither builds nor starts a guest. [31]
Each state can be valid independently while their association is stale. The debugger exposes that condition, and a retry against an outdated artifact cannot quietly create another run from newly observed sources. [20, 31]
7.3. Disposable workers and explicit execution plans
Owned playtests run the installed vcc-playtest helper in
a separate process. This is a practical response to the retained
one-machine-per-process constraint: test execution reuses the engine
without inserting another set of globals into the personal emulator
process. A worker receives a verified artifact or retained test disk, a
private writable copy, and the declared launch plan. It does not inherit
the user's personal cartridge topology, tapes, mounted drives, or
settings. Test disk retention preserves useful guest-produced state
without modifying its verified parent image. [22]
Receipts report the actual processor and observed HD6309 MD register and mode. Selecting HD6309 does not itself enable native mode or change the compiler target; guest instructions establish the mode. Restart retains the selected processor and writable disk. [32]
The worker advances through explicit bounded actions. Keyboard chords and complete joystick states are delivered for a specified number of emulated fields, with actual input/clock receipts. A field count is not a game-update count and can be interrupted by a verified breakpoint. Framebuffer capture is nonadvancing; instruction stepping is one CPU instruction rather than a C source step. Asynchronous startup exposes progress and cancellation without claiming a boot is complete before observed worker state establishes it. [22, 32]
7.4. Evidence capture and retry-safe external control
Graphics, text, debugger state, input observations, and audio have explicit execution effects. A framebuffer capture reads the retained state without consuming guest time. Audio capture deliberately advances a bounded interval, then pauses and returns guest-produced PCM before host gain or playback. The receipt identifies run, project, source revision, artifact, boot, actual field/cycle interval, sample counts, and payload hash. It does not represent a microphone recording or a measurement of perceived sound quality. [33]
Audio capture releases held input and drains earlier samples before the requested interval. Consequently it observes the following interval rather than the sound generated by a preceding input action; an analysis of continuously held movement must respect that contract. Silence likewise requires an appropriate signal measure: a constant DAC level can contain DC while having no audible variation. Nonzero sample count alone is not a universal criterion for erroneous sound. [33]
External clients can lose a response after the worker has already executed an action. Repeating that action naively would produce a second keypress, another boot, or a different clip. Request identifiers and plan matching make supported retries return the retained receipt instead of advancing again. Reusing an identifier for a different plan produces a conflict. A retained audio response remains associated with its original boot even if the worker subsequently restarts. Capability revocation and incompatible identities still prevent stale access; retry safety does not confer indefinite authority. [22, 33]
Resource limits constrain fields, boots, requests, readable ranges, and retained audio bytes. Stop and retention remain available after ordinary execution budgets are exhausted so a client can finish safely. These limits are part of the executable interface contract, not claims that bounded workloads represent all software. They also make it possible to present evidence with explicit totals and truncation rather than accepting unbounded inspection or silently discarding results. [22, 33]
7.5. Observation privileges and evidence interpretation
The Model Context Protocol interface builds on native services rather than bypassing them. A connection advertises its granted tools and capabilities; older grants retain their schema and do not inherit newly introduced access. Build, launch, read-only observation, input, and owned call context are separately constrained. The external debugger exposes verified named stops and snapshot-advertised ranges instead of arbitrary host paths, registers, or writable guest memory. Permission to compile a project is not permission to inspect the user's normal emulator session. [20, 22, 30]
The resulting platform supports an assistant or other client in a reproducible investigation: select an identified build, start an isolated worker, deliver a bounded input plan, stop at a verified location, and inspect evidence associated with that same state. It does not make the client's conclusions automatically correct. An uninterpreted stack window remains raw bytes, a decoded graphics page remains a selected rendering interpretation, and a single successful game route remains a bounded observation. The architectural contribution is that these distinctions are represented in the service contracts rather than left to a client's guess. [19, 22, 30]
8. Correctness Improvements and Integration Cases
I group the resulting behavior changes by the kinds of problems they address. Some corrected defects in shared inherited implementation; others made the new portable device models safer or more complete; a third group corrected mistakes in native integration. These categories matter because a defect found during a port is not necessarily a defect in the original platform's execution path. The following table summarizes the classification used below. The cases were selected for explanatory value and available regression evidence, rather than to estimate a defect rate for the entire inherited codebase.
| Case | Classification | Observable consequence | Principal evidence |
|---|---|---|---|
TST operand sampling |
Shared CPU correction | A VSYNC-polling editor could hang despite correct total instruction cycles | Edge-position fixtures and a selected real-cartridge probe |
| Scheduler construction and HD6309 reset | Shared state-consistency corrections | Undefined initial scaling or stale mode-dependent instruction timing | Scheduler and native-mode reset regressions |
| MMU and interrupt lifecycle | Shared correctness and robustness corrections | Wrong floating-bus source, retained interrupt inputs, or invalid memory references | Register/lifecycle checks and mapped guest execution |
| Raster bounds and frame progress | Shared rendering and execution corrections | Framebuffer overflow or an execution call that failed to return after a debugger halt | Guarded mode sweep, sanitizers, and frame-stop tests |
| FD-502 and hard-disk semantics | Portable adaptation improvements | Incomplete multi-sector behavior, misleading transfer status, or incorrect boundary data | Authored controller tests and selected disk round trips |
| HD6309 continuation and Multi-Pak signaling | Debugger and bus-state corrections | Stale transfer continuation or cartridge-present state | Targeted stepping and routing fixtures |
| Analog audio selection | Native integration correction | Idle cartridge output became an audible game-title buzz | Before/after PCM measurements and routing regressions |
| Transactional image editing | Native filesystem and media integration | A host edit could invalidate guest filesystem state or damage unrelated image regions | Whole-image rollback, region-preservation, and mounted-session fixtures |
| Mission Recorder | Guest SDK composition and integration validation | Individually usable libraries must also coexist, release resources, and preserve output across failures | Multi-library guest source and selected whole-program flight qualification |
8.1. Instruction timing and the Scripsit II polling failure
Color Scripsit II reached its menu but failed to enter its editor in
the native application. The relevant guest loop polls the PIA
vertical-synchronization flag using TST, while an interrupt
handler acknowledges that flag. The failure therefore involved the
ordering of three events: the flag's assertion, the operand read, and
interrupt handling. It could not be diagnosed adequately from a final
register value or total instruction cycle count alone. [49]
In the earlier execution path, the timing associated with the
instruction was advanced after the operand had been read. Under the
resulting schedule, the interrupt path could acknowledge each flag
transition before the polling loop observed it. The correction moves
addressing and data-cycle advancement before the read, leaving two
internal cycles after it. Direct, indexed, and extended TST
retain their total cycle counts and indexed addressing penalties. The
change applies to the MC6809 engine and the HD6309 engine in emulation
mode; the HD6309 native-mode path is unchanged. [49, 50]
Motorola's Figure 18 addressing and instruction diagrams provide the original processor reference used by the correction. The archived edition identifies the relevant sheets; the sampling-sequence claim is supported by the recorded implementation review and regression. The archived diagrams were not independently reverified for this paper. [72]
The regression fixture deliberately separates sampling time from total duration. For direct, zero-offset indexed, extended, and indexed-offset forms, it places a changing flag at every cycle position of the instruction. A bus callback checks the scheduler clock when the operand is read. The fixture also checks a single operand read, condition-code results, the retained carry state, and the total cycles. A second authored program recreates the conflict between polling and an IRQ handler that acknowledges the same peripheral flag. These checks are ROM-free and are reported to fail against the earlier implementations. [50]
The selected cartridge probe supplies complementary evidence. It boots the actual editor, observes polling-loop exit, enters text, checks retained memory, returns to the menu through the emulated keyboard matrix, and reenters the editor on both guest processors. The retained input record identifies the tested Scripsit II cartridge edition without redistributing the cartridge. [49]
The corrected sampling point restored editor entry by letting the guest observe the flag at the expected moment.
8.2. Scheduler initialization and processor reset consistency
Two extraction-time defects concerned derived state. The event
scheduler's constructor originally computed clock scaling from
mResolution before that member had been initialized. C++
initializes members in declaration order; initializer-list ordering does
not repair a dependency on a later member. The revised constructor uses
the defined default resolution when constructing the scaling fields.
Full reset also clears requested clock and overclock values, so a
subsequent rebase cannot restore an obsolete request. The corresponding
scheduler tests exercise initialization, exact-boundary behavior, event
ordering, rescheduling, rebasing, and reset. [49, 51]
The HD6309 reset path had a related logical inconsistency. It cleared native-mode bits but retained the cached native instruction timings. The apparent execution mode and the timing table could consequently disagree after reset. The corrected path invokes the existing mode-setting mechanism to restore emulation-mode timing as well as mode state. The native-mode fixture enters native mode, checks its behavior, resets, and verifies restoration; the development record identifies this as a regression that failed before the fix. [49, 50]
Both changes concern state transitions rather than new instruction functionality. They demonstrate why reset must be specified across all representations of a state variable, including cached tables and deferred requests.
8.3. MMU, floating-bus, and interrupt lifecycle corrections
The extracted machine tests exposed several assumptions that had
previously been distributed across application state. GIME floating-bus
reads consulted the MC6809 state even when the selected engine was the
HD6309. The corrected register path obtains the active processor through
the host boundary. CheckGimeRegisters contains an explicit
expectation that the read reflects the selected HD6309 rather than the
inactive MC6809. [52, 53]
PIA and GIME reset also require both internal and externally asserted state to be cleared. Clearing a peripheral latch without releasing its asserted CPU input can leave the processor observing a condition that the peripheral no longer records. The revised reset behavior releases those inputs, and tests separately exercise acknowledgement, independently asserted sources, and reset. Inspection tests ensure that a debugger read does not perform the acknowledgement that a normal guest read would perform. [52, 53]
Memory lifecycle changes address host safety. MmuInit
validates the RAM configuration and prepares replacement RAM and ROM
before replacing active allocations. Allocation or ROM-provider failure
preserves the current memory. Repeated teardown is safe, debugger page
access is bounded, and post-teardown inspection cannot dereference
released storage. SAM vector reads consult the current internal-ROM
allocation rather than retaining a stale cached pointer after
reinitialization. These changes protect the host process; they should
not be presented as increased historical-hardware fidelity. [52]
The integration fixture exercises the real MMU and register decoder
with both engines. Its authored guest switches tasks and pages, isolates
different byte values in physical pages, receives a GIME interrupt
through the SAM vector, stacks into mapped RAM, acknowledges the
interrupt, and returns with RTI. This establishes
interaction among selected components, not merely successful invocation
of a recording callback. It remains an authored source-contract test
rather than a captured Windows differential trace. [52, 53]
8.4. Raster memory safety, event ownership, and bounded progress
AddressSanitizer exposed an inherited framebuffer-overflow path in an oversized register combination. A 128-byte row interpreted at one bit per pixel derives 1,024 pixels. The renderer's unsigned stretch calculation could underflow when that width exceeded the supported surface, after which a border write reached beyond the framebuffer. The revised path leaves unsupported oversized layouts untouched and bounds duplicated border-row writes. [54]
CheckVideoPixels includes the precise oversized-layout
regression and surrounding guards. CheckVideoModes sweeps
2,304 CoCo 3 and compatibility-mode register combinations over their
active rows, checking framebuffer guards after rendering. The sweep is
useful evidence of exercised bounds, but it is not a claim that every
combination is a historically valid mode or that every rendered pixel
matches physical hardware. Separate authored expectations check known
colors, nibble order, scaling, scanlines, border placement, and a
CPU-driven color-bar image. [54, 55]
The extraction also makes GPU and callback ownership explicit. Raster operations use their own renderer rather than accidentally invoking a global Windows renderer. Reset establishes geometry and clears bookkeeping, while stop cancels owned raster and timer events. Weak lifetime guards prevent abandoned callbacks from dereferencing a destroyed renderer. Timer checks cover clock selection, restart and issue delays, overlapping delayed IRQs, zero-count stopping, and scanline countdown. The correction preserves multiple pending delayed IRQs when a timer period is shorter than the issue delay. [54]
RunFrame addresses a separate progress defect. It
returns on completed frame, debugger halt, exhausted budget, or a CPU
that makes no progress. A budget-limited partial frame can resume
without restarting the raster. The retained CPU API returns unused
cycles, and a final whole instruction can exceed the requested budget;
the wrapper preserves that distinction rather than assuming every call
consumes exactly its request. The Windows event-based frame loop also
uses this bounded operation, replacing a path that could wait
indefinitely after a breakpoint. Tests check halt return, limited work,
partial-frame resume, and stalled execution. [54, 55, 56]
8.5. Storage transfer semantics and image integrity
The portable FD-502 adaptation retains the inherited WD1793 command model while separating it from Windows handles, physical-floppy access, application preferences, and host filesystem writes. Its explicit ownership permits focused checks of drive state, buffers, mounted images, and cancellation. The changes include intentional improvements: malformed geometry is rejected before indexing or shifting, invalid sectors cannot alias an adjacent track, drive/side changes abort active transfers, and partial sectors do not commit. Whole write-track streams are validated before any sector changes. [57]
Multi-sector commands now advance until the next sector is unavailable. In the retained Windows implementation used for adaptation, the multi-sector flag was recorded without being used to advance the transfer. A separate completion correction prevents an end timeout from reporting lost data after the complete payload has already been serviced. The tests distinguish this condition from a genuinely unserviced transfer: a completed write commits once without a false lost-data flag, while the unserviced path reports lost data. These are observable controller semantics, not cosmetic changes to a host file dialog. [57, 58]
DMK and VDK support extends the representation layer. DMK retains address-table information, actual sector sizes, deleted-data marks, recorded CRCs, and mixed-density records. Writes update the relevant track data while preserving unrelated tracks. VDK parsing honors the declared header length, including extended headers. The Shamus fixture exposed a false address marker in a protected directory track; an authored-byte regression preserves the failure mechanism without requiring the original application disk. [57, 58]
The recorded real-media probe covers 54 distinct DMK images and two VDK images, found in 44 packages. An independently located sector was read from each image on both guest CPUs. For 55 writable images, the probe wrote a pattern to an owned in-memory copy, checked surrounding bytes, ejected and remounted it, reread it, and attempted a protected write. The remaining image rejected the initial write because of its header protection. I also recorded several application startup observations: Shamus reached its title screen, Color FLEX 5.0:4 reached its date prompt, and Kidwriter reached its loading screen. [57]
The virtual hard-disk adaptation corrects the Windows EOF loop's stale-last-byte behavior and an inclusive upper-bound error. Reads beyond the current image return zero-filled sectors within the defined maximum capacity, while writes can extend the image with zero-filled gaps. Bounds are checked before access, and DMA into I/O cannot recursively issue device commands. The portable image object tracks dirty-sector revisions so that a completed host save cannot acknowledge a newer guest write accidentally. The host-save protocol remains asynchronous: accepting a guest flush request is not equivalent to durable completion on the host filesystem. [59, 60]
I keep the controller model deterministic and make image updates transactional. Those choices support repeatable reads and preserve media during writes.
8.6. Debugger continuation and cartridge-bus state
The debugger adds execution paths that ordinary running software may
not exercise. HD6309 TFM is particularly important because
one instruction can transfer many bytes and span complete video frames.
The stepping implementation clears stale transfer continuation after PC
changes, resets, and invalid-instruction traps. Otherwise continuation
state associated with an earlier transfer could follow unrelated
instructions indefinitely. Targeted regression programs cover native and
emulation modes, interrupted and invalid transfers, and transfers
spanning multiple frames. Actual raster boundaries continue to govern
completed-frame counting. Explicit whole-instruction Step and Continue
from a breakpoint retain their documented, different stopping behavior.
[61]
The native Multi-Pak bus separately distinguishes the physical
startup selector from live ROM and disk-port routing. A software write
to $FF7F changes the selected routes. The adaptation
updates cartridge-present signaling when the ROM route changes, whereas
the retained Windows router updated that signal on physical selection
but omitted the software-write path. The change prevents a deselected
ROM from leaving stale auto-start state. Authored bus programs exercise
separate ROM and disk slots on both CPUs; a PIA check confirms that
cartridge presence follows the selected ROM. This is a documented
behavioral difference for which a fresh Windows runtime comparison
remained open in the milestone record. [62]
8.7. Native analog audio-routing correction
The audio case belongs to the native integration, not the inherited Windows mixer. A game's title screen produced a loud buzz with Speech/Sound present, although the same configuration was reported quiet on a physical CoCo. Disposable tests without that cartridge had not reproduced the problem. The native sampler mixed cartridge output regardless of the PIA analog selector and sound-enable gate. An idle unsigned cartridge midpoint of 128 became a DC offset; joystick polling switched the selector and chopped the offset into an audible waveform. [63]
The correction models the selected analog source: CoCo DAC, cassette input, cartridge sound, or grounded input. The sound-enable control gates that path. Cartridge PCM is centered at 128, with zero retained as a valid negative peak. Single-bit sound and the modeled Orchestra-90 external stereo outputs remain independent. Mixing saturates instead of wrapping, and device clocks continue while their output is muted or unselected. The authored routing test exercises these distinctions on both CPUs. [63, 64]
The unchanged-game probe provides unusually clear before/after evidence. With Speech/Sound present, the recorded title-screen interval had AC RMS 0.101581 on MC6809 and 0.101695 on HD6309 before correction; afterward every sample in that idle interval was zero. FD-502-only and FD-502-plus-Orchestra configurations remained digitally silent throughout. Subsequent ordinary game input produced movement effects with a recorded peak of 0.242188, showing that silence was not manufactured by muting the whole application. The retained input record identifies the unchanged game disk used for these observations. [63]
A native output test also recorded continued field advancement, sample consumption, and one audio-engine start during the silent title interval. The physical-machine observation independently supported the original diagnosis. [63]
The original CoCo 3 service manual describes the DAC, cassette, cartridge, and silent analog sources; the shared joystick/DAC role; and sound-enable gating with a separate single-bit path. Its explanatory prose supplies a primary hardware reference for the routing correction, distinct from the before/after game measurements. [73]
8.8. Transactional disk-image editing and mounted-state exclusion
A native filesystem editor introduces a second writer with a different view of the disk. The guest may retain directory, allocation, and open-file state in RAM while the host editor changes the corresponding image. A successful host write alone therefore cannot establish a safe transition back to guest execution. The VCC Plus editor separates three responsibilities: filesystem mutation within a selected region, preservation of the complete backing image, and coordinated replacement of media owned by the machine. This is a native integration contribution; the emulator's ability to mount a representation does not imply that the filesystem editor can safely modify it. [66, 67]
Filesystem operations reuse ToolShed's DECB and OS-9 RBF libraries. VCC Plus supplies the native wrapper, validation, transactions and mounted-machine coordination, including a separate wrapper path for multi-sector OS-9 allocation clusters. The contribution is safe composition and ownership control around existing filesystem routines. [66]
DiskImageEditorStore owns a private complete-image
working file and a separate extracted working volume. Retained C
operations and image I/O execute through this actor outside the main
actor. Each mutation first retains the complete image's previous bytes.
Successful changes to the extracted volume are merged into the selected
region; a failure restores the complete image and reextracts the volume.
A batch import or move consequently has a whole-operation rollback
boundary even if a lower-level writer has already changed some private
bytes. Undo and Redo likewise retain complete-image states, preserving
allocation metadata and edits across volume selections. History is
bounded, while retaining at least the most recent undo state; these
snapshots are an explicit memory cost of the chosen design. [67]
Region selection is deterministic. A recognized OS-9 filesystem begins at byte zero and declares its extent. Numbered HDB-DOS volumes occupy fixed-size Disk BASIC slots at byte zero or after that declared extent. Invalid and unformatted slots retain their positions and bytes; discovery does not scan for arbitrary partition signatures or initialize unknown space. External OS-9 boot extents are validated against the complete image, excluded from overlapping writable slots, and preserved when filesystem bytes are merged back. Supplementary DECB tracks and opaque tails similarly remain outside the allocatable file area. Free-space accounting describes the selected filesystem, not every byte in its backing file. [66, 68]
Mounted editing adds a machine-owned lease. The serialized controller refuses a busy transfer, pauses execution, releases held keyboard state, and captures current guest-visible bytes with a token, machine generation, and media identity. Execution and conflicting media changes remain excluded while that lease exists. Cancel releases the lease with original media intact and leaves the machine paused. Apply requires explicit restart confirmation, current-session validation, compatible size and geometry, writable media, and resolution of unrelated dirty media or captured output. Replacement is prepared before commit; the controller performs the cold restart and media replacement without an intervening guest instruction. The restart prevents guest code from reusing filesystem state derived from the old image. Native drafts and unrelated media assignments remain outside that replacement. [67, 68]
The final file path retains source-identity and external-change checks. Standalone replacement requires the original bytes still to match; mounted automatic-save paths use their existing coordinated writes, while temporary media retain dirty bytes without silently changing save policy. An edited copy can be exported when replacing the source is prohibited. These are bounded transaction and conflict-detection guarantees. They do not establish crash-consistent commits across guest state and the host filesystem, nor do they promise recovery from every storage-device failure. [67]
The public fixtures expose the relevant invariants directly.
DiskImageBackendTests checks source-copy isolation,
malformed-chain rejection, disk-full rollback, supplementary-byte
preservation, descriptor-preserving OS-9 moves, exact-image Undo/Redo,
hard-disk region isolation, and external boot preservation.
DiskEditorSafetyTests checks mounted locks and cancellation
on both guest CPUs, unconfirmed-commit refusal, stale sessions,
temporary media, aliases, and externally changed sources. Recorded
execution on both host slices and selected native import/export and
Apply/reopen paths supplement these authored invariants. [68, 71]
Supported editing is deliberately narrower than mounting: validated raw DECB and OS-9 regions, bounded image and file sizes, and specified allocation geometries. DMK/VDK conversion, arbitrary repartitioning, filesystem repair, and precise physical-media behavior are outside this editor. This case extends the architectural argument from execution ownership to data ownership: a reusable machine core needs an equally explicit protocol when native tools modify resources that the guest can also write.
8.9. Mission Recorder as a whole-program SDK integration case
Individually correct libraries can still fail when they share mappings, interrupts, sample storage, and cleanup paths. Mission Recorder tests that composition in an ordinary guest C program: page-flipped GIME graphics, sampled keyboard/joystick input, banked observations, optional Speech/Sound, interrupt-driven Orchestra-90 playback, Disk BASIC files, and serial output. A marked sector is stored through the bank library and read back during saving; subsequent craft movement must not overwrite it. Each display page retains its own drawing state, while background playback requires resident sample data and valid mappings throughout foreground work. [69]
Cleanup follows hardware ownership. Stereo stops before its sample storage or shared resources can be released. Speech timeouts reset the operation and restore the prior analog route. Graphics and bank mappings are closed before ROM-backed file and printer calls, and early failures release resources already acquired. The program preserves an observation across a failed save so retry does not require repeating the flight. Its requested Orchestra-90 configuration is not a hardware-presence probe. [69]
The output path verifies the observation independently of the displayed scene. It chooses an unused temporary/final filename pair, preserves earlier reports and interrupted drafts, writes and closes the draft, reopens it, compares every byte and exact EOF, and checks the second close before renaming. Only then does it transmit the same report bytes through the printer service. This establishes readback and collision-avoidance contracts, not power-loss atomicity or physical delivery to paper. [69]
The harness checks the banked mark, separate ship/marker pixels, speech progress and stereo DAC activity during steering. After cleanup it compares MMU banks, the BASIC interrupt vector and palette with their initial values, evaluates a new BASIC calculation, and requires background DAC writes to stop. A protected-write failure must preserve disk and printer bytes; a later retry must publish the next eligible filename without replacing previous reports, drafts, or the executable. Extracted disk output must equal the captured serial stream. [70]
The retained qualification reports 32 flights: seven FD-502 scenarios
at two optimization levels on each guest CPU, plus four Release boots
across RGB-DOS and CoCo SDC profiles. The scenarios cover direct/disk
launch, silent operation, each audio service separately, requested
devices absent, and discard. One marked-sector flight retained 15 at
physical address $50000 and produced the same 27 bytes on
disk and serial output: MISSION RECORDER\rSECTOR 15\r. A
protected-write retry selected LOG03.TXT while preserving
LOG01.TXT and LOG02.TMP. These are retained
November 2026 observations, not new executions for this paper. [70, 71]
The audio observations record modeled chip and DAC activity. The print check compares serial bytes. The flight validates how the libraries share resources, recover from failed writes, and return control to BASIC.
9. Evaluation Design and Recorded Evidence
9.1. Evidence model and experimental units
I evaluate the design through mechanism-specific regressions, subsystem integration, and selected probes using real programs. The principal unit is a declared claim under a stated configuration, rather than an undifferentiated count of passing tests. An instruction fixture establishes a sampling or state-transition expectation; a complete-machine fixture exercises CPU, MMU, scheduler, and devices together; a native check addresses presentation, asynchronous control, or host output; a selected application probe adds evidence of compatibility for its observed path. None substitutes automatically for the others.
I report results with the corresponding cases and give the fixture, inputs, and configuration in the supporting record. [49, 52, 54, 57, 59, 61, 63, 65, 71]
9.2. Running the core independently
I use authored, ROM-free fixtures to run the extracted core independently of its graphical host. The baseline core and device suite passed, including instruction and reset checks for both emulated processors. For experiments using original software and media, the harness identifies the input bytes and directs writes into owned copies. [77]
9.3. Sustained timing and the value of retained failures
With a 50 ms audio reserve, the earlier 30-minute runs recorded 1,888 missing sample frames for MC6809 and 1,029 for HD6309. The latter already used interactive queue priority. That result pointed me toward the reserve as the next mechanism to test. [65]
I increased the reserve to approximately 100 ms and filled it before output started. A modeled 80 ms producer stall directly exercised the change. The subsequent 30-minute runs recorded zero missing or overflow samples on either guest processor. The maximum sampled audio timing deviation was 7.738 ms for MC6809 and 10.018 ms for HD6309. [65]
The timing harness sampled counters about once per second and counted audio before output gain. That let me compare frame progress and sample consumption during the run. [65]
9.4. Debugging-service integrity criteria
Correct source displays require more than plausible values. My evaluation criteria include unchanged guest cycles and state during inspection; agreement among registers, MMU mapping, and captured memory; invalidation after source, artifact, generation, or mapping changes; refusal of wrong-bank or modified-code source claims; and explicit unavailability at unsupported frame boundaries. Historical trace bytes must remain unchanged after self-modification or later debugger edits. Execution-changing operations, such as source stepping or audio capture, must state their effects and retain their execution identity.
These criteria tie each source association to a supported frame, the verified executable bytes, and current mapping. The result tables report the behavior of the specified inspection and execution operations.
9.5. Observation-integrity experiment
I use an API-level probe to exercise the composed core with an
authored 32 KiB replacement ROM and 512 KiB RAM. The guest executes
INC $4000; BRA $8000, giving the experiment a visible
memory change and genuine frame progress without a private system ROM.
Each guest is loaded, advanced, paused, inspected, resumed, and
destroyed serially. The probe runs the same sequence on MC6809 and on
HD6309 in reset emulation mode. [78]
Nine check designs test actual service behavior: initial real-frame progress; explicit I/O availability; repeated nonadvancing observations; logical/physical backing agreement; rejection of invalid ranges; refusal of stale source-step identities; retained memory after an explicit edit; retained frames and memory after real execution; and retained observations after reset. For the repeated-observation check, sixteen iterations interleave logical range reads, whole-physical-RAM reads, a current graphics capture, and an explicit HSCREEN preview. The comparisons include all exposed CPU fields; MMU task and effective-map fields; run state and identities; cycles and frames; all 65,536 captured logical bytes and their availability flags; all 524,288 physical RAM bytes; breakpoint state; and published frame pixels. [78]
All nine check designs passed on both emulated processors. Six invalid range forms and four independently stale identities were rejected without changing the compared state. The fixture also demonstrated real execution rather than a permanently frozen machine: guest frame counts advanced from 1 to 2 and cycle counts from 14,997 to 29,987 in each reported guest run. Retained results preserved their old bytes and pixels after later edits, execution, and reset. The inspected source matched the reviewed input set; the receipt separately identifies the probe, runner, executable and linked library. [78]
I use this fixture to check that inspection services preserve the captured state they expose.
9.6. Bounded differential comparison with XRoar
An authored common-instruction program was executed in the real VCC
core and the installed XRoar 1.12. Both used 512 KiB RAM, the same
authored 32 KiB replacement system ROM, and no cartridge or external
media. XRoar read an explicit empty configuration and ran with null UI,
null audio, and configuration autosave disabled. Every process had a
finite wall-time limit. The comparison used MC6809, HD6309 emulation
mode, and an HD6309 variant that executed LDMD #$01 before
the common program. [79]
The fixture initializes the common compared registers before entering
the observation interval. A sixteen-iteration loop writes bytes 1
through 16 at $4100–$410F; a second loop reads them through
indexed addressing and accumulates their sum. VCC supplies immutable
normal execution trace records; XRoar supplies its headless instruction
trace. Normalization compares each instruction-entry PC with the
post-instruction CC, A, B, DP, X, Y, U, and S fields. VCC additionally
reads the final RAM directly. For XRoar, each individual byte read is
reconstructed from the accumulator change modulo 256 at
ADDA ,Y+, with the accessed address obtained from the
post-instruction Y value. This is a stated inference from guest
execution, not a claim of direct XRoar memory inspection. [79]
| Guest configuration | Compared dynamic rows | Equal rows | Verified individual readbacks | Final A / B / CC | Stop PC |
|---|---|---|---|---|---|
| MC6809 | 115 | 115 | 16 | $88 / $00 / $54 |
$8027 |
| HD6309 emulation | 115 | 115 | 16 | $88 / $00 / $54 |
$8027 |
HD6309 after guest LDMD #$01 |
115 | 115 | 16 | $88 / $00 / $54 |
$802A |
Every case ended with X and Y equal to $4110, U equal to
zero, S equal to $7000, and DP equal to zero. Both
processes exited zero for each case, and the normalized trace hashes
matched pairwise. The native-mode VCC observation directly reported MD =
1. XRoar's trace showed the LDMD instruction, but this
channel did not expose its MD value directly. Initial E/F/V values are
unused and excluded; the fixture does not treat differing unspecified
reset contents as a semantic failure. [79]
I use the comparison to corroborate the register sequence and memory behavior of the two emulator implementations. [79]
9.7. Target-executed compiler correctness regressions
A further paper-specific experiment compiles the three authored regression programs associated with indexed byte subtraction, indexed function arguments, and logical negation. Fixture source and the guest-execution harness come from the reviewed VCC Plus source set. The staged CMOC 0.1.100 compiler advertises all three correction markers. This corrected development runtime is distinguished from the shipped compiler used in Section 9.8. No stock or deliberately defective compiler is used in this fresh experiment. Historical before-fix evidence remains identified separately. [34, 35, 80]
I compiled the fixtures at both -O0 and -O2
and executed the resulting binaries on MC6809 and HD6309. The matrix
records 24 guest executions and identifies the compiler
build used for each. [80]
| Regression fixture | Expected screen marker | Generated binaries | Passing guest executions |
|---|---|---|---|
| Indexed byte subtraction | HX AC96806A0001A9F0008000EA42BE |
4 | 8 |
| Indexed function arguments | ARGS , three repetitions of
040C0810141C1820, then END |
4 | 8 |
| Logical negation | NOT 010 1000 END |
4 | 8 |
Every execution terminated with its expected marker observed by the ROM-backed harness. The linked record identifies the compiler payload, fixture-specific options, generated bytes, system-ROM input and guest output. These results concern the corrected compiler; historical before-fix discrimination is reported with the corresponding defects in Section 6.8. [80]
The output markers corroborate the corrected indexed arithmetic, argument loads, and logical negation. The next experiment compares a wider set of mutable output bytes.
9.8. Shipped-compiler optimization study and default selection
The separate CoCoBenchmarks study used the compiler shipped in VCC Plus 3.6.2 build 55 on November 12, 2026. The tested compiler is the universal CMOC 0.1.100 runtime packaged with that application build; the upstream compiler version alone would not distinguish this payload from other integrations. The indexed-subtraction, indexed-argument, add-zero-flags, and debug-metadata markers are all present. No patch was added or compiler rebuilt during that study. Its purpose was to assess generated-project optimization defaults in an already corrected compiler. It is not a stock-CMOC comparison or an estimate of the performance cost of the correctness patches. [40, 81]
9.8.1. Experimental units and correctness gate
Eight authored workloads represent fixed-point arithmetic,
sprite-state updates, memory/checksum processing, sorting/state
transitions, framebuffer writes, sample-buffer mixing, input scanning,
and sector-directory processing. Each operates on synthetic application
buffers. The matrix uses seeds 1, 165, and 65521; two repeats; Debug
(-O0 -fno-omit-frame-pointer), Release (-O2),
and Release with -fomit-frame-pointer; two explicitly
selected compiler host slices; and MC6809, HD6309 emulation, and HD6309
native execution. The product is 864 executions. CMOC
emits 6809 instructions in every profile. The harness explicitly enables
HD6309 native mode for that separate execution dimension. Normal
generated-project relocation and switch defaults are preserved, with a
2048-byte stack allowance. [81]
The study compares every serialized mutable output byte with an independently specified Python reference model. It does not accept a matching checksum as a substitute for matching the covered state. All 864 executions passed. Repeated cycle counts agreed exactly, and equivalent builds from the two compiler host slices had identical guest-binary hashes. For this paper, I rechecked the recorded matrix and reference outputs using the retained evidence. [81]
9.8.2. Cycle and size measurements
The timing interval begins immediately before the workload call and ends after its return. Setup and result serialization lie outside the interval; call and return costs remain inside it. Guest IRQ and FIRQ are masked. An independent three-NOP calibration gives 6 cycles on MC6809 and HD6309 emulation and 3 cycles on HD6309 native mode. The reported values count emulated guest cycles, without baseline subtraction or host elapsed-time conversion. Two deterministic repetitions check repeatability; they are not independent noisy samples from which statistical confidence intervals would be justified. [81]
The following MC6809 cycle counts are arithmetic means across the three seeds, rounded to whole cycles for presentation. Each workload receives equal weight in the cross-workload geometric mean. The byte columns measure initialized DECB payload, excluding container headers and uninitialized BSS. They include linked runtime helpers, startup, setup, and result-collection code, so they do not isolate the workload function's size. Stack and heap reservations are separate from the reported initialized payload. [81]
| Workload | Debug cycles | Release cycles | Omit cycles | Release bytes | Omit bytes |
|---|---|---|---|---|---|
| Fixed arithmetic | 163,697 | 158,916 | 158,518 | 977 | 960 |
| Sprite state | 446,728 | 410,519 | 410,467 | 1,160 | 1,133 |
| Memory/checksum | 570,717 | 461,316 | 459,660 | 657 | 630 |
| Sort/state | 103,003 | 83,826 | 82,446 | 860 | 833 |
| Framebuffer | 706,813 | 632,676 | 632,616 | 721 | 699 |
| Sample mixing | 191,326 | 151,049 | 150,649 | 669 | 642 |
| Input scanning | 30,119 | 26,118 | 25,366 | 877 | 845 |
| Sector directory | 160,249 | 131,204 | 131,140 | 920 | 893 |
Release uses 14.17% fewer MC6809 cycles than Debug under the equal-workload geometric mean. Relative to existing Release, omission uses 0.69% fewer cycles on MC6809 and HD6309 emulation and 0.84% fewer cycles on HD6309 native execution. For a comparison, the calculation takes each workload's ratio of mean cycles, forms the geometric mean of those eight ratios, and subtracts it from one. This weights workloads equally rather than allowing the longest fixture to dominate the result. Each host compiler slice gives the same values. [81]
Summed initialized payload falls from 6,841 to 6,635 bytes across the eight MC6809 programs, a 3.01% reduction; HD6309 emulation gives the same result. Native-mode variants total 6,865 and 6,659 bytes, a 3.00% reduction. Per-program savings are 17–32 bytes. Input scanning supplies the largest MC6809 cycle reduction from omission, 2.88%. These totals describe eight separate executables, including their individual harness and runtime overhead; they are not a predicted saving for one combined application. [81]
9.8.3. Choosing the default optimization profile
The measured Release improvement supports retaining the existing
-O2 default. The much smaller additional cycle improvement
from frame-pointer omission does not, by itself, justify making that
experimental option universal. Preserved Debug frames support the
verified local-variable and caller conventions used by VCC Plus. The
recorded engineering decision therefore retains Debug and Release
defaults and leaves omission available as an explicit project choice.
This keeps the measured performance benefit available while preserving
the ordinary debugging convention. [40, 81]
The framebuffer, audio, input, and sector-directory workloads measure CPU-side algorithms. I compare their guest cycle counts and output bytes under the declared build profiles. [81]
The shipped-build study and the corrected development-runtime matrix in Section 9.7 use separately identified compiler payloads; their results do not describe one uniform application build. [81]
10. Discussion
10.1. Architectural extraction as a method of finding assumptions
I answer RQ1 with an architecture that defines explicit operations and ownership for the retained engine and its hosts. Processor code requests memory operations and debug hooks. Register logic requests machine services. Raster code writes to an owned surface through a video contract. A composed session serializes the retained machine state, and the native bridge publishes observations across the language and thread boundary. The approach preserves useful existing algorithms while changing the dependencies through which they interact with their environment.
The architecture lets me test at three scales. A flat memory bus exercises instruction behavior. A recording host shows whether register writes reach a device. The composed machine then exercises the timer, processor, and interrupts together. [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
The work also demonstrates why an interface should not be confused with elimination of all inherited constraints. The retained global CPU state, scheduler, and host bindings still prevent independent machines from sharing one process without additional work. The occupancy claim guards lifecycle exclusion, while serialization governs actual operations. These are different mechanisms. Explicitly documenting both is more useful than describing the engine as reentrant on the basis of its new classes alone.
10.2. Correctness includes the placement of observations
For RQ2, I identify several categories of defect in the case studies. Initialization and memory-safety changes address undefined or unsafe host execution. Mode-reset and interrupt cleanup changes address internal consistency after lifecycle transitions. Device changes repair register and transfer semantics while retaining an intentionally simplified hardware model. Native sound routing corrects a new integration path. These categories should remain separate in any assessment of how much the inherited emulator changed.
The Scripsit case illustrates the distinction between total instruction time and the moment a guest observes hardware. The polling instruction and the interrupt handler competed to read or acknowledge the same synchronization flag. Moving the operand read within the instruction changed whether the loop could finish while preserving the instruction's duration. [49, 50]
The audio case offers a different lesson. Testing a game without the relevant sound cartridge configuration did not reproduce the user's failure. The eventual reproduction preserved the game and its inputs while varying the device topology. The correction followed source selection, gating, sample centering, and mixing semantics rather than suppressing the observed waveform globally. A compatibility fixture is stronger when it retains the relevant configuration and demonstrates both removal of the unintended signal and preservation of intended output. [63, 64]
10.3. Debugging interpretation requires an evidence chain
For RQ3, I separate an observation from the interpretation attached to it. A consistent memory capture can accurately report bytes while offering no justified C frame. An executable symbol can identify a real entry without supplying a source statement. A bank declaration can describe intended placement without proving the guest has installed the module. The source-map, relocation, runtime-guard, and metadata services address different links in this chain. Their checks are complementary rather than interchangeable. [23, 24, 25, 26, 27, 28, 29, 30]
The conservative unwinder and call-context service illustrate the operational consequence. They require supported code and storage relationships before naming callers or arguments. They do not scan for plausible return addresses to produce a longer stack. Unavailability is therefore part of the service's successful behavior when its prerequisites are absent. This principle is particularly important for assistant clients, which can otherwise turn an apparently authoritative numeric response into an unsupported explanation.
Each check has a specific role. A content hash identifies bytes. A mapping fingerprint checks whether the logical and physical views still agree. The executable guards tie source associations to those bytes, and the bounded watch language evaluates supported expressions over captured state.
10.4. Programmable investigation without a second source of machine truth
I address RQ4 through two ownership boundaries. Within an interactive process, one machine owner governs commands and snapshots. For disposable testing, a separate worker process owns its own machine and writable test-media copy. The first boundary prevents native windows from becoming competing controllers of shared state; the second accommodates inherited process-wide globals while separating investigation from a personal session. [5, 22, 31, 32, 33]
Capability discovery, opaque result identities, explicit field budgets, and retry-safe request IDs make external automation reviewable. A repeated request can return its prior receipt rather than deliver another key press or advance another audio interval. A revoked or incompatible project does not retain an apparently valid observation merely because a client remembers its address. These are service-level properties that support robust experimentation, though they do not establish that an external client will interpret every result correctly.
A responsive host is a separate requirement from a deterministic guest sequence. Bounded asynchronous work, immutable export, and nonadvancing capture reduce avoidable interference. They cannot guarantee identical wall-clock latency under every host workload. The paper therefore treats execution clocks, output-device consumption and application responsiveness as different measurements.
The same ownership principle appears at two additional boundaries. The guest SDK temporarily borrows MMU windows, display pages and interrupt service paths; it must restore them before returning to ROM-backed I/O. The disk editor privately owns a proposed filesystem state while the guest is excluded from the mounted image, then requires explicit restart when applying it. Neither a writable buffer nor a paused CPU alone supplies that complete contract. Mission Recorder exercises the first boundary across several services, while editor fixtures exercise cancellation and byte-preserving recovery at the second. Their evidence is complementary to instruction-level regressions, because correct individual components can still conflict through shared mapping, interrupt or media state. [41, 42, 43, 44, 45, 66, 67, 68, 69, 70, 71]
10.5. Interpreting the evidence
I combine independently specified expectations, before-and-after regressions, real-software probes, and a comparison with another emulator. Each gives me a different way to exercise the behavior that motivated a change.
The XRoar experiment compares registers and memory behavior for a common instruction sequence. Agreement gives me a second implementation against which to check the sequence. [79]
The observer probe compares captured registers, RAM, mappings, identities, and published pixels before and after the inspection calls. I pair that comparison with availability flags so the debugger exposes supported bytes without triggering the hardware effects of an ordinary I/O read.
I use the three compiler fixtures to isolate the corrected transformations. In the shipped-compiler experiment, an independent host reference checks the serialized outputs and repeat runs show whether cycle counts agree. Together these experiments connect the targeted corrections to the choice of a default build profile. [80, 81]
10.6. What the application checks show
I used existing applications to observe specific interactions with the composed machine. The Scripsit editor entry isolated an operand-sampling issue, disk save and reopen exercised the media path, and gameplay exercised the audio correction. Each observation adds a program-level check alongside the smaller fixture. [49, 57, 63, 71]
10.7. Source and evidence availability
VCCPlusOSS supplies the implementation and its build documentation; the supporting-evidence collection supplies the experiments, selected source excerpts and evidence records. Public file references, dated configurations and stated host/guest dimensions identify the material supporting each claim. ROMs and populated collections are separate inputs. The source edition retains executable capabilities with empty collections; reproduction of optional-input experiments still requires their declared inputs. [46, 47]
11. Conclusion
In VCC Plus, I modernized a mature emulator by retaining its implementation, defining explicit host contracts, and grounding the development services in runtime evidence. The work separates processor, memory, register, raster, and selected device behavior from the original Windows application while composing them within a serialized native Mac host. Extraction exposed software-safety and guest-visible defects whose corrections are supported by targeted regressions and selected complete-program observations.
The debugging extensions make a second contribution beyond platform portability. Consistent capture, runtime identity, executable/source verification, physical-bank awareness, compiler-described storage, conservative stack interpretation, interpreter-aware stepping, bounded tracing, graphics observation, and constrained call context establish the conditions under which a runtime explanation is supported. Isolated programmable workers extend those conditions to automated development and investigation. Transactional editing protects filesystem state across native/guest ownership changes; guest SDK contracts protect shared mappings, interrupts and display resources. Mission Recorder supplies a concrete integrated example of those guest contracts and their failure paths.
I used observation-integrity probes, differential comparison, and target-executed compiler regressions to check those mechanisms. The compiler measurements informed a concrete choice: retain ordinary Release optimization and keep frame-pointer omission available as an explicit project setting. In VCC Plus, separating the host and verifying what a debugger can say about runtime state proved to be closely related design decisions.
Acknowledgments and Attribution
I designed VCC Plus with sponsorship from Dezota LLC. I build on the work of the original VCC contributors and the authors of retained processor, device, compiler, assembler, library, and reference material. Their original copyright and license notices remain applicable. I thank the Color Computer Archive for the historical publications and software provenance used in this paper. The archive retains its own attribution, and each work remains subject to its applicable distribution terms. XRoar is credited to Ciaran Anscomb and its contributors. CMOC and LWTools retain their upstream author and contributor credits. Native hardware artwork is outside the evaluated core and retains its separate notices, including the SockMaster inspiration credit where that artwork is used.
Appendix A. Interface and Service Boundaries
| Boundary | Authoritative responsibility | Observation or operation supplied |
|---|---|---|
| CPU memory interface | Shared processor/MMU integration | Byte/word access and map selection; explicit isolated test bus |
| CPU debugger hooks | Owner-installed synchronous hook object | Halt/step eligibility and actual instruction/interrupt observations |
| Machine host | Composed machine or recording fixture | Required ROM, device, input, interrupt, timer, tape, and printer connections |
| Video host | Host-owned render surface | Surface access, clearing, active area, artifact policy, and frame completion |
| Machine session | One loaded machine per process | Serialized lifecycle, execution, safe inspection, media/device composition |
| Native controller | Application command queue | Asynchronous command ordering and immutable main-queue completion |
| Source-map verifier | Retained build evidence | Object/listing/link/source consistency and executable guards |
| Metadata/stack interpreter | Captured state plus supported compiler evidence | Typed storage, verified frame suffix, scoped values, explicit unavailability |
| Playtest worker | Separate process and owned media copy | Bounded execution/input, captured output, restart and retention receipts |
The service catalog in research/services.md
maps these responsibilities to implementation layers. Public tool
schemas expose selected operations; they do not make every internal
native operation available to every connection.
Appendix B. Representative Code Mechanisms
The following short listings are selected or line-reformatted for
presentation. They are not complete subsystems. Verbatim payloads,
original notices, selected line counts, payload hashes, and hashes of
the published excerpt files are retained under snippets/
and in snippets/manifest.json.
Listing B1. Explicit termination conditions in the production frame runner. These tests occur in a loop around normal CPU execution; a completed instruction may exceed the remaining budget. [12]
if (gpu.FrameFinished())
return {FrameStop::Complete, cycles};
if (CpuDebugger().IsHalted())
return {FrameStop::Halted, cycles};
if (cycles >= cycleBudget)
return {FrameStop::Budget, cycles};The explanatory harness compiles the complete verbatim function against small host stand-ins. It checks completion, halt before and during execution, finite budget, stall, final-instruction overshoot, and missing-CPU rejection. These algorithm checks are separate from the complete-core execution evidence.
Listing B2. Availability is distinct from captured byte storage. The production snapshot service publishes an availability flag and performs a non-destructive read only for safe locations. [16]
const bool safe = location < 0xff00 ||
(location >= 0xff90 && location <= 0xffbf) ||
location >= 0xfff0;
result.memoryAvailable[i] = safe;
if (safe)
result.memory[i] = SafeMemRead8(location);Listing B3. A source step is conditional on the paused identity. The call is rejected before execution if a captured generation, program revision, mapping, or PC is stale. Byte and module checks supply additional conditions later in the operation. [16]
if (expectedGeneration != generation ||
expectedProgramRevision != debuggerProgramRevision ||
expectedMappingFingerprint !=
mappingFingerprint(GetMMUState()) ||
expectedPC != impl->CpuState().PC)
throw std::invalid_argument(
"The paused program changed; refresh before C stepping");Listing B4. The corrected direct-addressed TST separates sampling from its trailing internal cycles. The surrounding instruction decoder supplies the operand address and flag helpers. [49, 50]
Cycles(4);
temp8 = MemRead8(temp16);
cc[Z] = ZTEST(temp8);
cc[N] = NTEST8(temp8);
cc[V] = false;
Cycles(2);Appendix C. Evidence Records
The supporting-evidence collection retains the fixture sources, measured results and source-excerpt provenance linked below. Build and reproduction instructions accompany those artifacts. The reported host and guest configurations delimit the results; generating a reading edition does not repeat an experiment.
| Record | Technical claim supported |
|---|---|
research/services-qualification.md |
Disk-editor transactions, guest-library contracts and the Mission Recorder integration |
snippets/manifest.json |
Source selections and original notices for the representative mechanisms |
research/results/core-checks.json |
ROM-free core and device results |
research/results/observer-invariants.json |
Nonadvancing inspection and retained-capture invariants |
research/results/xroar-comparison.json |
Common instruction-state and readback agreement |
research/results/cmoc-regressions.json |
Executed regressions for the corrected compiler transformations |
research/results/cmoc-benchmark-summary.json |
Correctness-gated cycle and code-size comparisons |
research/archive-citations.json |
Historical publication editions and inspected locators |
References
Implementation and selected technical records are linked by file path in VCCPlusOSS. Paper-specific methods, excerpts and public evidence records are available as supporting evidence. Named versions, validation dates and stated configurations distinguish the reported results.
Reference 1
docs/macos/PORTING_PLAN.md.
Product constraints, source baseline, implementation scope, source
organization, device decisions, and validation distinctions.
Reference 2
docs/macos/CPU_CORE.md.
Processor extraction, ownership requirements, register representation,
execution budget semantics, and authored validation.
Reference 3
docs/macos/MACHINE_CORE.md.
MMU/register extraction, host connections, memory lifetime, failure
semantics, and machine checks.
Reference 4
docs/macos/GRAPHICS_CORE.md.
Surface contracts, raster/timer ownership, frame execution, and renderer
checks.
Reference 5
docs/macos/MAC_CONTROLLER.md.
Session lifecycle, singleton ownership, native queue, frame delivery,
and historical bridge qualification.
Reference 6
docs/development/REPOSITORY_LAYOUT.md.
Shared implementation and host ownership boundaries.
Reference 7
src/core/CpuMemory.h;
src/core/CpuMemory.cpp.
CPU memory contract and explicit isolated-bus override.
Reference 8
src/core/CpuHost.h;
src/core/CpuHost.cpp.
Synchronous debug hooks, Windows forwarding adapter, and non-Windows
default.
Reference 9
src/core/MachineHost.h;
src/core/MachineHost.cpp.
Required machine connections, host installation, and Windows
adapter.
Reference 10
docs/macos/CARTRIDGES.md;
src/devices/CartridgeDevice.h.
Device ownership, Multi-Pak routing, reset, and persistence
boundaries.
Reference 11
docs/macos/NATIVE_BOOT.md.
Native ROM boot, Metal submission, input, and optional-input
validation.
Reference 12
src/core/FrameRunner.h;
src/core/FrameRunner.cpp.
Bounded frame-execution algorithm and result semantics.
Reference 13
src/core/VideoHost.h;
src/core/VideoHost.cpp.
Extracted surface and video-host contracts.
Reference 14
docs/macos/AUDIO_CASSETTE.md;
src/core/AudioBuffer.h.
Scheduled samples, native output consumption, bounded buffering, and
interruption limitations.
Reference 15
src/core/MachineSession.h;
src/core/MachineSession.cpp;
platforms/macos/Bridge/VCCMachineController.mm.
Authoritative machine configuration, ownership, snapshot identities, and
asynchronous native integration.
Reference 16
src/core/MachineSession.h;
src/core/MachineSession.cpp,
especially mappingFingerprint,
debuggerSnapshot, debuggerMemoryRange, and
debuggerStepSource; src/core/FrameRunner.h;
src/core/FrameRunner.cpp;
platforms/macos/Bridge/VCCMachineController.mm;
docs/macos/MAC_CONTROLLER.md.
Reference 17
docs/development/CMOC_SOURCE_DEBUGGING.md;
platforms/macos/App/CMOCVariableDebug.swift;
platforms/macos/App/CMOCWatchEvaluator.swift;
platforms/macos/App/CMOCCallStack.swift.
Reference 18
docs/macos/DEBUGGER.md;
src/core/CpuHost.h;
src/core/hd6309.cpp;
platforms/macos/App/DebuggerModel.swift.
Reference 19
docs/macos/DEBUGGER_MEMORY_TOOLS.md;
src/core/DebugDisassembler.cpp;
src/core/MachineSession.cpp,
graphics-preview and memory-range services.
Reference 20
docs/development/MCP_DEBUG_EVIDENCE.md;
platforms/macos/App/MCPDebuggerInspection.swift;
platforms/macos/App/CMOCSourceMap.swift;
platforms/macos/App/MCPCMOC.swift.
Reference 21
docs/macos/DEBUGGER_TRACING.md;
src/core/MachineSession.h,
trace record and snapshot declarations; src/core/MachineSession.cpp,
trace capture/export; src/core/CpuHost.h,
instruction and interrupt trace hooks.
Reference 22
docs/development/MCP_BANKED_PLAYTEST.md;
platforms/macos/App/MCPPlaytest.swift;
platforms/macos/App/MCPCMOCGuest.swift.
Reference 23
platforms/macos/App/CMOCSourceMap.swift,
especially verifiedSections, relocation evaluation,
listing/object byte comparison, and retained provenance.
Reference 24
tools/toolchain/patches/README.md;
tools/toolchain/patches/cmoc-debug-metadata.patch;
docs/development/CMOC_SOURCE_DEBUGGING.md.
Reference 25
platforms/macos/App/CMOCCallStack.swift,
particularly capture, frame validation, and direct-call
target decoding.
Reference 26
platforms/macos/App/CMOCBankedDebug.swift;
docs/development/MCP_BANKED_PLAYTEST.md,
build-evidence manifest contract.
Reference 27
src/core/BasicProgram.h;
src/core/BasicProgram.cpp;
src/core/MachineSession.cpp,
BASIC source-transfer/debug services; docs/development/BASIC_WORKSPACE.md.
Reference 28
docs/development/ASSEMBLY_WORKSPACE.md;
platforms/macos/App/AssemblyBuildService.swift;
platforms/macos/App/AssemblyDevelopmentModel.swift.
Reference 29
docs/development/CMOC_RUNTIME.md;
sdk/cmoc;
tools/toolchain/patches/README.md;
platforms/macos/App/CMOCBuildService.swift.
Reference 30
VCC Plus project (2026). Bounded call-context implementation and
authored checks: docs/development/MCP_CALL_CONTEXT.md;
platforms/macos/App/CMOCOwnedCallContext.swift;
platforms/macos/Tests/CMOCOwnedCallContextTests.swift;
platforms/macos/Tests/MCPCallContextAccessTests.swift.
The technical record distinguishes the implementation contract and
observed qualification. The public source index is retained in research/evidence.json.
Reference 31
docs/development/MCP_PROJECT_RELIABILITY.md;
platforms/macos/App/CMOCProjectInputs.swift;
platforms/macos/App/CMOCBuildService.swift.
Reference 32
docs/development/MCP_PLAYTEST_PROCESSORS.md;
docs/development/MCP_BUILD45_VALIDATION.md.
Reference 33
docs/development/MCP_AUDIO_CAPTURE.md;
platforms/macos/App/MCPPlaytest.swift.
Reference 34
tools/toolchain/patches/cmoc-indexed-byte-subtraction.patch;
tools/toolchain/patches/cmoc-indexed-argument-load.patch;
tools/toolchain/patches/cmoc-add-zero-flags.patch;
tests/toolchain/indexed-subtraction/qualification.c;
tests/toolchain/indexed-arguments/qualification.c;
tests/toolchain/logical-negation.c;
tools/toolchain/patches/README.md.
Reference 35
docs/development/CMOC_INDEXED_ARGUMENT_LOAD.md;
tests/toolchain/indexed-arguments/check.py;
tests/toolchain/indexed-arguments/check-rule.py;
tests/toolchain/indexed-arguments/optimizer-rule.cpp.
Reference 36
third_party/manifests/cmoc-make-dependencies.patch;
tools/toolchain/cpp-mcpp.c;
tools/toolchain/cmoc-runtime.sh;
tools/toolchain/verify-runtime.py;
docs/development/CMOC_RUNTIME.md.
Reference 37
third_party/README.md;
third_party/manifests/cmoc.json;
tools/toolchain/build.py;
tools/toolchain/build-runtime.py.
Import patches and later build-copy transformations have distinct
provenance.
Reference 38
tools/toolchain/patches/writecocofile-before-dir.patch;
tools/toolchain/patches/lwtools-project-inputs.patch;
tools/toolchain/patches/README.md.
Reference 39
docs/development/CMOC_RELEASE_QUALIFICATION.md;
docs/development/CMOC_RUNTIME.md.
Dated installed-runtime and relocation qualification, including the
source/staged-binary mismatch.
Reference 40
docs/development/CMOC_BENCHMARKS.md.
Shipped-compiler benchmark summary and unchanged Release-default
decision; detailed source and numerical evidence reside in the
separately identified CoCoBenchmarks artifact.
Reference 41
Banked guest assets and authored regression coverage: sdk/cmoc/include/vcc/bank.h;
sdk/cmoc/bank/bank.c;
tests/toolchain/bank/qualification.c;
tests/toolchain/bank/run.cpp.
Source inspection identifies reservation, preflight, mapping and
condition-code restoration contracts; execution evidence is separately
dated.
Reference 42
GIME drawing and presentation: sdk/cmoc/include/vcc/gime.h;
sdk/cmoc/gime/gime.c;
tests/toolchain/gime/qualification.c;
tests/toolchain/gime/run.cpp.
The supported BASIC entry state, physical-page layout, bounded timer
wait, and restoration limits are explicit in the implementation and
fixtures.
Reference 43
Orchestra-90 foreground and background protocols: sdk/cmoc/include/vcc/orch90.h;
sdk/cmoc/orch90/play.c;
sdk/cmoc/orch90/background.c;
tests/toolchain/orch90-background/qualification.c;
tests/toolchain/orch90-background/run.cpp.
Reference 44
Sampled guest input and upstream composition: sdk/cmoc/include/vcc/input.h;
sdk/cmoc/input/input.c;
tests/toolchain/input/qualification.c;
tests/toolchain/input/run.cpp;
third_party/manifests/bcontrol.json.
Reference 45
Bounded C compatibility: sdk/cmoc/compat/include/stdio.h;
sdk/cmoc/compat/include/stdlib.h;
sdk/cmoc/compat/format.c;
sdk/cmoc/compat/streams.c;
sdk/cmoc/compat/heap.c;
sdk/cmoc/compat/tests/compat-check.c;
tests/toolchain/streams/qualification.c;
tests/toolchain/stream-writes/qualification.c;
tests/toolchain/stream-writes/update.c;
tests/toolchain/heap/qualification.c;
third_party/manifests/decbfile.json;
third_party/manifests/wydealloc.json.
These are bounded guest facilities with file-specific upstream notices,
not a complete hosted C runtime.
Reference 46
Shared content-profile implementation and public build configuration:
README.md;
tools/build_content.py;
tools/tests/test_build_content.py;
tools/catalog/package.py;
tools/catalog/app-schema.sql;
tools/knowledge/package_archive.py;
tools/knowledge/archive-library.sql;
tools/manuals/lookup_resources.py;
platforms/macos/Tools/bundle-manual-library.py;
platforms/macos/Tools/prepare-toolchain.py;
platforms/macos/Packaging/copy-development-starter.sh;
platforms/macos/Resources/RuntimeTemplates.json;
platforms/macos/Resources/BASICReference.json;
platforms/macos/Resources/AssemblyReference.json;
platforms/macos/VCC.xcodeproj/project.pbxproj.
Reference 47
Explicit public dependency preparation: third_party/README.md;
tools/dependencies/fetch.py;
tools/dependencies/tests/test_fetch.py;
third_party/manifests;
tools/dependencies/manifests/legacy-graphics.json;
tools/toolchain/verify-sources.py;
tools/toolchain/build-runtime.py.
Source inspection establishes the preparation and refusal mechanisms;
upstream licenses and notices remain component-specific.
Reference 48
research/services-qualification.md.
Public technical projection of retained, dated SDK and build-profile
qualification, preserving configuration and scope limits. Source
inspection and executed qualification remain distinct evidence
categories.
Reference 49
docs/macos/CPU_CORE.md,
CPU extraction record and November 4, 2026 Scripsit II timing
correction.
Reference 50
tests/core/CpuChecks.cpp,
especially testOperandTiming, Check6309Native,
and CheckEventScheduler; implementations in src/core/mc6809.cpp
and src/core/hd6309.cpp;
optional tests/macos/scripsit-compatibility-probe.cpp.
Reference 51
src/core/Event.cpp,
Event::Event, Reset, and
Rebase.
Reference 52
docs/macos/MACHINE_CORE.md,
machine-host boundary, lifecycle rules, corrections, and initial
validation.
Reference 53
tests/core/MachineChecks.cpp,
CheckMmuLifecycle, CheckGimeRegisters,
CheckPiaInterrupts, and
CheckMappedCpuExecution; implementations in src/core/tcc1014mmu.cpp,
src/core/tcc1014registers.cpp,
and src/core/mc6821.cpp.
Reference 54
docs/macos/GRAPHICS_CORE.md,
portable interfaces, mode sweep, corrections, and qualification
limits.
Reference 55
tests/core/VideoChecks.cpp,
CheckVideoPixels, CheckVideoModes,
CheckRasterTiming, CheckGimeTimers,
CheckVideoLifecycle, and CheckFrameStops.
Reference 56
src/core/FrameRunner.h
and src/core/FrameRunner.cpp,
bounded execution contract and implementation.
Reference 57
docs/macos/FLOPPY_CORE.md,
November 1 controller milestone and November 5 DMK/VDK extension.
Reference 58
tests/core/FloppyChecks.cpp,
transfer, image, damaged-record, protection, and session fixtures; src/devices/FD502/Fd502Device.cpp,
src/devices/FD502/DiskImage.cpp,
and optional tests/macos/fd502-media-probe.cpp.
Reference 59
docs/macos/HARD_DISKS.md,
device protocol, asynchronous saving, validation, and limitations.
Reference 60
src/devices/HardDisk/HardDiskDevice.h,
HardDiskImage::read, write,
capture, and acknowledge; platforms/macos/Tests/HardDiskCoreTests.mm
and platforms/macos/Tests/HardDiskTests.swift.
Reference 61
docs/macos/DEBUGGER.md,
execution semantics and dated debugger-completion validation; platforms/macos/Tests/DebuggerTFMTests.mm.
Reference 62
docs/macos/CARTRIDGES.md,
routing differences, authored guest checks, and November 1 integration
evidence; src/devices/CartridgeDevice.h.
Reference 63
docs/macos/AUDIO_ROUTING.md,
November 11 cause analysis and unchanged Quadrapassel game-disk probe,
with digital measurements and native output qualification.
Reference 64
tests/core/AudioCassetteChecks.cpp,
CheckAudioRouting; tests/macos/audio-game-validation.cpp;
native sampling in src/core/MachineSession.cpp.
Reference 65
docs/macos/TIMING_RELIABILITY.md,
November 1–2 timing and sustained-use evidence, failed 50 ms runs, final
100 ms runs, and interruption limits; tests/core/TimingChecks.cpp
and tests/macos/run-sustained-check.sh.
Reference 66
third_party/manifests/toolshed.json,
selected ToolShed filesystem revision, provenance, exclusions, and
unmodified snapshot; platforms/macos/Bridge/DiskImageEditorBackend.mm,
filesystem validation, bounded volume discovery, region replacement, and
cluster-aware wrapper operations.
Reference 67
platforms/macos/App/DiskImageEditorModel.swift,
DiskImageEditorStore mutation/restore and model Undo/Redo;
platforms/macos/App/DiskEditorSession.swift,
host contract and bounded source-identity/compare/write implementation;
platforms/macos/App/MachineModel.swift
and platforms/macos/Bridge/VCCMachineController.mm,
mounted lease, prepare/commit/cancel, source checks, and restart
ordering.
Reference 68
platforms/macos/Tests/DiskImageBackendTests.swift
and platforms/macos/Tests/DiskEditorSafetyTests.swift,
authored filesystem preservation, rollback, region, lease,
source-conflict, cancellation, and restart fixtures.
Reference 69
examples/cmoc/MissionRecorder/main.c,
examples/cmoc/MissionRecorder/flight.c,
examples/cmoc/MissionRecorder/report.c,
examples/cmoc/MissionRecorder/mission.h,
examples/cmoc/MissionRecorder/Makefile,
and examples/cmoc/MissionRecorder/vccplus-project.json,
foreground composition, cleanup, report readback/publication, and build
declarations.
Reference 70
tests/toolchain/mission-recorder/check.py,
tests/toolchain/mission-recorder/run.cpp,
and tests/toolchain/mission-recorder/profiles.cpp,
declared optimization/CPU/scenario matrix, ordinary guest input,
graphics/bank/audio observations, protected retry, exact disk/printer
comparisons, restoration checks, and alternate-storage launch
probes.
Reference 71
research/services-qualification.md,
curated retained qualification for native disk editing and composed SDK
examples, including the separately dated disk-editor checkpoints and
Mission Recorder flight matrix; no new runs are claimed by the present
sections.
Reference 72
Motorola, Inc. (1983). MC6809 HMOS 8-Bit Microprocessing
Unit, DS9845-R2, Figure 18, sheets 3–5, physical pages 24–26. Color
Computer Archive catalog document 2492. Archived
original. Edition identity and inspected text locators: research/archive-citations.json.
Reference 73
Tandy Corporation (n.d.). Color Computer 3 Service Manual:
NTSC/PAL Version with 512K Expansion RAM Card, catalog 26-3334.
Radio Shack. Sections 1.4, 5.3, 5.5, and 5.8; physical pages 9–10,
36–37, 39, and 41–43. Color Computer Archive document 1717. Archived
original. Edition and inspected locators: research/archive-citations.json.
Reference 74
Spectral Associates; electronic reconstruction/revision by Walter K.
Zydhek (1999). Color BASIC Unravelled II, revised December 26.
Interpreter Mechanics, physical pages 9–10 (printed 7–8); Appendix B,
physical pages 48–50 (printed B22–B24), listing lines 1931–2107. Color
Computer Archive document 1106. Archived
edition. The date identifies the electronic revision. Edition and
inspected locators: research/archive-citations.json.
Reference 75
Spectral Associates; electronic reconstruction/revision by Walter K.
Zydhek (1999). Extended BASIC Unravelled II, revised December
26. Appendix B, Extended BASIC 1.1, physical page 32 (printed B4),
listing lines 0289–0316. Color Computer Archive document 4570. Archived
edition. Edition and inspected locators: research/archive-citations.json.
Reference 76
Spectral Associates; electronic reconstruction/revision by Walter K.
Zydhek (1999). Disk BASIC Unravelled II, revised December 26.
Appendix B, Disk BASIC 1.1, physical page 49 (printed B14), listing
lines 1249–1259. Color Computer Archive document 2413. Archived
edition. Edition and inspected locators: research/archive-citations.json.
Reference 77
VCC Plus paper experiments (2026). Supporting universal Release core
checks and verified input manifest. research/results/core-checks.json;
research/results/core-source-inputs.json.
November 12. Source baseline and executable identities are recorded in
the receipts.
Reference 78
VCC Plus paper experiments (2026). Observation-integrity probe and
reproduced host-slice results. experiments/observer-invariants/probe.cpp;
experiments/observer-invariants/run.py;
research/results/observer-invariants.json.
Reference 79
VCC Plus paper experiments (2026). Authored VCC/XRoar differential
fixture. experiments/xroar/common-loop.asm;
experiments/xroar/vcc-fixture.cpp;
experiments/xroar/run.py;
research/results/xroar-comparison.json.
Installed XRoar 1.12, Ciaran Anscomb and contributors.
Reference 80
VCC Plus paper experiments (2026). Target-executed CMOC correctness
regression matrix. experiments/cmoc-regressions/run.py;
research/results/cmoc-regressions.json.
November 12. Three pinned C fixtures, two optimization levels, two
explicitly selected compiler host slices, and two guest processors; 24
passing guest executions. Corrected staged compiler and native arm64
emulator harness are identified separately.
Reference 81
Holman, B. K. (2026). CoCoBenchmarks: shipped CMOC optimization
qualification, November 12. VCC Plus 3.6.2 build 55; eight authored
workloads, three build profiles and three guest execution modes. The
paper companion retains the study source in experiments/cmoc-benchmarks/,
the numerical record in research/results/cmoc-benchmark-recorded.json,
the recalculated summary in research/results/cmoc-benchmark-summary.json,
and the evidence-validation procedure in tools/import_cmoc_benchmark.py.
This is prior execution evidence revalidated for the paper, not a fresh
repetition of 864 guest runs.