chore(wails): remove all Wails references and dependencies

- Remove EventEmittingWriter (Wails-specific) from service layer
- Replace with simple output buffer for non-API usage
- Update README.md to replace Wails with Avalonia GUI
- Update CLAUDE.md to remove gui/app_test.go reference
- Update main.go help text to reference Avalonia instead of Wails
- Remove unused Wails runtime import

All Go tests passing (1024 tests)

Author: lookbusy1344

CLAUDE.md

@@ -25,7 +25,7 @@ go clean -testcache && go test ./...
 ./arm-emulator program.s
 ```
 
-**Test Organization:** Tests in `./tests/unit/` and `./tests/integration/` (exceptions: `gui/app_test.go`, `debugger/tui_internal_test.go`)
+**Test Organization:** Tests in `./tests/unit/` and `./tests/integration/` (exception: `debugger/tui_internal_test.go`)
 
 ## Swift GUI (macOS, Primary GUI)
 

README.md

@@ -6,13 +6,13 @@ This is an example of using vibe coding to re-create my first commercial project
 
 Here I am attempting to use Claude Code to broadly recreate the emulator as a cross-platform Go project, with a simple TUI debugger. Claude was given a one-paragraph prompt and essentially left to its own devices, with only gentle high level steering.
 
-After the TUI interface, I went on to make a cross-platform GUI using Wails. While this works, I was dissatisfied with the webview interface, so **the Wails GUI is now deprecated**. The current GUI is a **native Swift app for macOS** that provides a superior native experience, calling into the Go VM using a REST API. Perhaps later I will write a Windows GUI using the same backend, using WinUI or WPF.
+After the TUI interface, I added a REST API backend to support GUI frontends. The project now includes two native GUI applications: a **Swift app for macOS** and an **Avalonia app for Windows/Linux/macOS**, both calling into the Go VM using the REST API.
 
 The project therefore consists of:
 
 - A Go backend implementing the ARM2 emulator, CLI and TUI debugger, and REST API for GUI integration
 - A native Swift macOS app providing a GUI frontend using SwiftUI and MVVM architecture
-- (Deprecated) A Wails cross-platform GUI using web technologies
+- An Avalonia cross-platform GUI using .NET and ReactiveUI (Windows/Linux/macOS)
 
 ## Security
 
@@ -200,9 +200,15 @@ open ARMEmulator.xcodeproj
 - [docs/HTTP_API.md](docs/HTTP_API.md) - REST API and WebSocket reference
 - [openapi.yaml](openapi.yaml) - OpenAPI 3.0 specification
 
-#### Wails Cross-Platform GUI (Deprecated)
+#### Avalonia Cross-Platform GUI
 
-Web-based GUI available for reference. See [Wails.md](Wails.md) and [docs/GUI.md](docs/GUI.md).
+.NET-based GUI for Windows, Linux, and macOS. Built with Avalonia UI and ReactiveUI using MVVM architecture.
+
+**Requirements:** .NET SDK 10.0+
+
+**Documentation:**
+- [docs/AVALONIA_IMPLEMENTATION_PLAN.md](docs/AVALONIA_IMPLEMENTATION_PLAN.md) - Implementation details
+- [docs/HTTP_API.md](docs/HTTP_API.md) - REST API and WebSocket reference
 
 ### Symbol Table Dump
 
@@ -341,8 +347,8 @@ Download pre-built binaries with SHA256 checksums from [Releases](https://github
 ├── tools/               # Development tools (lint, format, xref)
 ├── api/                 # HTTP REST API backend for GUIs
 ├── service/             # Service layer for API/GUI integration
-├── swift-gui/           # Swift native macOS app (SwiftUI + MVVM) - Primary GUI
-├── gui/                 # Wails cross-platform GUI (DEPRECATED)
+├── swift-gui/           # Swift native macOS app (SwiftUI + MVVM)
+├── avalonia-gui/        # Avalonia cross-platform GUI (.NET + ReactiveUI)
 ├── tests/               # Test files (1,024 tests, 100% passing, 75% coverage)
 ├── examples/            # Example ARM assembly programs (49 programs)
 └── docs/                # User and developer documentation

main.go

@@ -752,7 +752,7 @@ Diagnostic Modes:
   -register-trace-format Register trace format: text, json (default: text)
 
 Examples:
-  # Start API server for GUI frontends (Swift app, Wails app)
+  # Start API server for GUI frontends (Swift app, Avalonia app)
   arm-emulator -api-server
   arm-emulator -api-server -port 3000
 

service/debugger_service.go

@@ -2,7 +2,6 @@ package service
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"io"
 	"log"
@@ -48,7 +47,7 @@ func init() {
 }
 
 // DebuggerService provides a thread-safe interface to debugger functionality
-// This service is shared by TUI, GUI, and CLI interfaces
+// This service is shared by TUI, API/GUI frontends, and CLI interfaces
 //
 // Lock Ordering:
 // The service uses its own sync.RWMutex (s.mu) to protect all field access,
@@ -59,7 +58,7 @@ func init() {
 // This is safe because:
 // - The TUI uses the Debugger's internal mutex directly (no service mutex)
 // - The service always acquires s.mu before any Debugger method that uses d.mu
-// - The GUI only accesses debugger state through the service
+// - The API/GUI frontends only access debugger state through the service
 //
 // Do NOT acquire locks in the reverse order (debugger.mu -> s.mu) as this
 // would create a deadlock risk.
@@ -72,9 +71,8 @@ type DebuggerService struct {
 	sourceMapByAddr      map[uint32]string // Quick lookup by address (for debugger)
 	program              *parser.Program
 	entryPoint           uint32
-	outputWriter         *EventEmittingWriter
-	ctx                  context.Context
-	stateChangedCallback func() // Callback for GUI state updates
+	outputBuffer         *bytes.Buffer // Output buffer for VM output (when not using API)
+	stateChangedCallback func()        // Callback for GUI state updates
 
 	// stdin redirection for guest programs (GUI)
 	stdinPipeReader *io.PipeReader
@@ -106,13 +104,6 @@ func (s *DebuggerService) GetVM() *vm.VM {
 	return s.vm
 }
 
-// SetContext sets the Wails context for event emission
-func (s *DebuggerService) SetContext(ctx context.Context) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.ctx = ctx
-}
-
 // SetStateChangedCallback sets a callback for GUI state updates during execution
 func (s *DebuggerService) SetStateChangedCallback(callback func()) {
 	s.mu.Lock()
@@ -157,17 +148,13 @@ func (s *DebuggerService) LoadProgram(program *parser.Program, entryPoint uint32
 		}
 	}
 
-	// Create output buffer with event emission
-	// IMPORTANT: Only set OutputWriter if it hasn't been configured already.
-	// The API server sets up EventWriter for WebSocket broadcasting before calling LoadProgram.
-	// The GUI (Wails) doesn't pre-configure OutputWriter, so we set up EventEmittingWriter for it.
+	// Note: OutputWriter should be configured by the API layer before calling LoadProgram.
+	// The API server sets up EventWriter for WebSocket broadcasting.
+	// If OutputWriter is still os.Stdout, set up a buffer to capture output for GetOutput().
 	if s.vm.OutputWriter == os.Stdout {
-		// OutputWriter is still the default (os.Stdout), so set up event emission
-		outputBuffer := &bytes.Buffer{}
-		s.outputWriter = NewEventEmittingWriter(outputBuffer, s.ctx)
-		s.vm.OutputWriter = s.outputWriter
+		s.outputBuffer = &bytes.Buffer{}
+		s.vm.OutputWriter = s.outputBuffer
 	}
-	// else: OutputWriter was already configured (e.g., by API layer), leave it alone
 
 	// Load into debugger
 	s.debugger.LoadSymbols(s.symbols)
@@ -590,15 +577,19 @@ func (s *DebuggerService) GetExitCode() int32 {
 }
 
 // GetOutput returns captured program output (clears buffer)
+// Note: With the API server, output is broadcast via WebSocket events.
+// This method is primarily used by tests and direct service usage (not via API).
 func (s *DebuggerService) GetOutput() string {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
-	if s.outputWriter == nil {
+	if s.outputBuffer == nil {
 		return ""
 	}
 
-	return s.outputWriter.GetBufferAndClear()
+	output := s.outputBuffer.String()
+	s.outputBuffer.Reset()
+	return output
 }
 
 // GetDisassembly returns disassembled instructions starting at address.