Online C# Compiler & Runner

The .NET and Roslyn Compilation Architecture in WebAssembly

Modern browser-based C# execution bridges the Microsoft Roslyn compiler platform with the WebAssembly (.NET WASM) runtime. Rather than routing compilation requests to remote servers where proprietary logic could be intercepted or delayed by cold starts, the NexaTools C# compiler runs a virtualized Common Language Runtime (CLR) inside the client browser. When source code is entered into the editor, it is parsed by the Roslyn compiler engine, which builds syntax trees and analyzes semantic bindings across namespace imports (including System, System.Collections.Generic, and System.Linq). Roslyn validates syntax rules against modern C# language specifications (C# 9.0 through C# 12) and generates Common Intermediate Language (CIL/MSIL) portable executable assemblies directly within memory.

The compiled CIL bytecode is executed by an in-browser Mono/CLR WebAssembly engine. The runtime uses an interpreted or ahead-of-time (AOT) JIT pipeline compiled to wasm32, mapping CIL opcodes into native processor instructions inside the browser WebAssembly sandbox. This architecture provides full type safety, garbage collection, and reflection capabilities without requiring a local .NET SDK installation on your machine.

Garbage Collection and Memory Lifecycle in the Browser CLR

Managing memory within WebAssembly requires coordination between the .NET Garbage Collector (GC) and the browser engine's WebAssembly linear memory allocator. The browser instantiates a contiguous block of linear memory that serves as the unmanaged heap for the virtualized CLR. Inside this space, the .NET runtime manages the managed heap, dividing allocations into standard generation spaces (Gen 0 for short-lived temporary objects, Gen 1 as an observational buffer, and Gen 2 for long-lived static resources and application singletons):

• Object Allocation: Whenever statements invoke new List<T>() or construct reference types, pointers are allocated sequentially on the Gen 0 managed heap using bump-pointer allocation for minimal overhead.
• Generational Compaction: When Gen 0 reaches capacity, an ephemeral collection sweeps unreferenced objects, compacting surviving references and promoting them to Gen 1. Because memory resides strictly within the WebAssembly linear buffer, memory fragmentation does not leak to the host operating system.
• Stack vs Heap Dispositions: Primitive value types (int, double, struct) and Span<T> allocations operate on the execution stack, achieving zero-allocation performance for high-throughput computational loops.

Standard Stream Virtualization (Console.WriteLine and Console.ReadLine)

In standard desktop environments, Console.WriteLine writes to the operating system's standard output handle via native Windows or Linux kernel calls. Within the WebAssembly browser sandbox, direct OS handles are inaccessible. The runtime overcomes this through a managed interop redirection layer:

• Standard Output Redirection: Console.SetOut() is bound to a custom internal TextWriter stream. Calls to Console.WriteLine() serialize strings into UTF-8 byte arrays that fire JavaScript callback interop events, dynamically appending formatted lines to the terminal console element in the DOM.
• Standard Error Interception: Unhandled exceptions, stack traces, and runtime errors written to Console.Error are tagged with distinct styling classes, enabling clear distinction between program output and CLR runtime warnings.
• Interactive Input Virtualization: Console.ReadLine() hooks into the virtual standard input buffer. When standard input is provided in the optional input panel, the stream yields line-buffered strings sequentially to waiting blocking calls.

Step-by-Step Execution Lifecycle

The end-to-end execution workflow proceeds through five deterministic stages:

1. Source Ingestion & Preprocessing: The C# source is extracted from the editor, wrapping top-level statements into a canonical Program.Main entry point if modern top-level program syntax is used.
2. Roslyn Lexical & Semantic Analysis: The compiler validates type constraints, identifier scopes, and method signatures, generating diagnostics for any syntax or semantic violations.
3. CIL Emission: Validated ASTs emit a portable CIL binary assembly stored purely in browser memory (ArrayBuffer).
4. CLR WebAssembly Execution: The virtualized .NET runtime loads the assembly, resolves entry points, and begins execution on the virtual thread.
5. Stream Flushing & Session Reset: Output buffers flush to the UI console, and temporary assembly allocations are recycled, ensuring pristine state for subsequent runs.