Familiar syntax.
Native systems.

using System;

namespace Examples;

public static class Program
{
    [EntryPoint]
    public static void Main()
    {
        uint left = 2u;
        uint right = 3u;
        uint result = left + right;
        Console.WriteLine(result);
    }
}

public class Base
{
    protected int number;

    public Base(int number)
    {
        this.number = number;
    }

    public virtual int Read()
    {
        return number;
    }
}

public class Derived : Base
{
    public Derived() : base(4) { }

    public override int Read()
    {
        return base.Read() + 1;
    }
}

using System;
using System.IO;

public static class Program
{
    [EntryPoint]
    public static void Main()
    {
        FileHandle image = File.Open(
            "image.ppm",
            FileMode.Create,
            FileAccess.Write);

        defer File.Close(image);
        Console.WriteLine("Rendering...");
    }
}

public static class NativeInterop
{
    [Extern("ct_native_utf8_length")]
    [NoAlloc]
    [NoThrow]
    [NoBlock]
    public static uint Utf8Length(
        NativeUtf8String value);
}

public static class Program
{
    [Interrupt]
    [Export("timer_isr")]
    public static unsafe void TimerIsr(void* context)
    {
        // Compiler-checked runtime-free IRAM closure.
    }

    [Export("ctilde_add")]
    [NoRuntime]
    [NoBlock]
    public static int Add(int left, int right)
    {
        return left + right;
    }
}

public class Box<T>
{
    public T Value;
}

public static T Identity<T>(T value)
{
    return value;
}

public struct Buffer<T, const int Capacity>
{
    public T[Capacity] Items;
}

Box<int> box = new Box<int>();
Buffer<byte, 64> buffer;

try
{
    Work();
}
catch (SpecificException error)
{
    Console.WriteLine(error.Message);
}
catch (Exception)
{
    throw;
}
catch
{
    Console.WriteLine("fallback");
}
finally
{
    Console.WriteLine("cleanup");
}

public static unsafe void Clear(
    byte* address,
    int length)
{
    for (int index = 0; index < length; index++)
    {
        address[index] = 0;
    }
}

unsafe
{
    NativeBuffer<byte> data =
        stackalloc byte[128];
    data[0] = 42;
}

[NoAlloc]
asm (
    in value as source,
    out("&r") result,
    ref accumulator,
    clobber("eax", "cc", "memory")
) {
    movl source, %eax
    addl %eax, accumulator
    movl %eax, result
}

[NoRuntime]
[NoBlock]
public static unsafe asm void DebugWrite(char value)
    (in("a") value as output)
{
    outb output, $0xe9
}

[NoRuntime]
[NoBlock]
public static unsafe asm uint ReadPort()
    (out("a") result as value)
{
    inl $0xf4, value
}

DebugWrite('C');
uint status = ReadPort();

[Packed(4)]
public readonly struct MultibootHeader
{
    public readonly uint Magic;
    public readonly uint Flags;
    public readonly uint Checksum;

    public MultibootHeader(uint magic, uint flags, uint checksum)
    {
        Magic = magic;
        Flags = flags;
        Checksum = checksum;
    }
}

[ConstInit]
[Used]
[Section(".multiboot")]
[Align(4)]
private static readonly MultibootHeader Header =
    new MultibootHeader(
        0x1BADB002u,
        0x00000003u,
        0u - 0x1BADB002u - 0x00000003u);

static assert(sizeof(MultibootHeader) == 12u);

[Export("kernel_main")]
[NoAlloc]
[NoBlock]
public static unsafe int Main()
{
    Write("CTILDE_QEMU_OK\n");
    return 0;
}

[Naked]
[Export("_start")]
[NoAlloc]
public static unsafe asm void Start()
{
    cli
    cld
    movl $stack_top, %esp
    xorl %ebp, %ebp
    call ct_runtime_initialize
    call kernel_main
    movl %eax, %ebx
    call ct_runtime_shutdown
    movl %ebx, %eax
    outl %eax, $0xf4
1:
    hlt
    jmp 1b
}

using System.Collections;

List<int> values = new List<int>();
values.Add(2);
values.Insert(0, 1);

ListEnumerator<int> items = values.GetEnumerator();
while (items.MoveNext())
    Console.WriteLine(items.Current);

F32x4 a = rays.Directions.LengthSquared();
F32x4 halfB = centerToOrigin.Dot(rays.Directions);
F32x4 c = centerToOrigin.LengthSquared()
    - F32x4.Splat(radius * radius);

F32x4 discriminant = halfB * halfB - a * c;
Mask32x4 hits = F32x4.CompareGreaterThanOrEqual(
    discriminant, F32x4.Zero);

using Esp.Idf.Storage;

RemovableSdCardMonitor card =
    new RemovableSdCardMonitor(
        SdSpiConfiguration.TCan485);

card.AddFatMount(0, "/sd", 8);
card.Start();

if (card.State == RemovableStorageState.Faulted)
    card.Remount();

using System.Diagnostics;
using System.Text;

[EntryPoint]
public static int Main(string[] args)
{
    Process current = Process.Current;
    byte[] payload;
    if (current.TryReceive(250u, out payload))
        Console.WriteLine(Encoding.UTF8.GetString(payload));
    if (Process.IsCancellationRequested)
        return -1;
    return 0;
}

[RuntimeImpl(Runtime.ConsoleWrite)]
[NoAlloc]
[NoThrow]
[NoBlock]
[NoRuntime]
private static unsafe RuntimeTransferResult ConsoleWrite(
    ReadOnlyNativeBuffer<byte> value)
{
    // Platform-specific output.
    return new RuntimeTransferResult(
        RuntimeStatus.Success, 0, value.Length);
}