SkylineBuild .NET apps
for the age of agents.
Skyline is the agent-native app framework for .NET — one codebase, every platform, WebGPU-first and built on a clean slate. Agents build with it, the apps they build are safe by default, and it runs your AI pipeline, not ours.
A window and a live frame, in ten lines.
Open a window and Skyline hands you a working device and swapchain. Handle resizes, encode your passes against the current view, present. The frame is yours — raw wgpu always one property away.
Run it now — dotnet run --project samples/HelloWindow
using var win = new AppWindow(new() { Title = "hello" }); using var gpu = GpuContext.Create(win.Surface); win.Resized += f => gpu.Surface.Configure(f.PixelWidth, f.PixelHeight); win.RenderFrame += f => { // stale swapchain, retry next frame if (!gpu.Surface.TryAcquireFrame()) return; // encode passes against gpu.Surface.CurrentView // with raw wgpu (gpu.Api) — the frame is yours gpu.Surface.Present(); }; return win.Run();
A foundation for apps, built clean for what comes next.
Skyline hands you a window, a GPU device, an app loop, and the safety rails agentic apps need — then lets you render your own UI on top. It is a foundation, not a widget toolkit. WebGPU-first on a clean slate, so nothing legacy sits between your code and the metal, and NativeAOT everywhere, so apps start fast and ship small. Starling renders a whole browser on it. So can your app.
Every platform, one codebase
Windows, macOS, Linux, iOS, and the web from a single .NET project. NativeAOT throughout — small native binaries, fast startup, no runtime to install.
WebGPU-first, clean slate
Built on a modern GPU API with no legacy baggage. Direct control of the device, the swapchain, and every frame — raw wgpu always one property away, nothing hidden.
Built for agents to build with
A flat, predictable API an agent can hold in its head. Every sample is one runnable file it can check with --frames N. Errors are loud and immediate, so an agent gets feedback fast and never stalls behind an abstraction.
Safe by default
Permissions, capabilities, and approvals are built in. Every action knows who asked — a person, an AI, an automation — and sensitive ones go through Allow / Allow once / Deny. Stop re-rolling that, insecurely, in every app.
Your AI pipeline, not ours
No required model, no SDK to route through, no loop we own. Bring whatever agent or pipeline you already use. Skyline is the framework, not the gatekeeper.
Latency that stays flat
An optional FrameLoop owns the per-frame ritual and caps frames in flight — one native call per frame, zero allocation. Many windows run on one device, each on its own thread, so a 60 Hz window never throttles a 144 Hz one.
To build with — and to operate safely.
Most frameworks were designed for a person typing in an IDE. Skyline is designed for the new reality: agents writing the code, and agents acting inside the running app. Both halves are built in, not bolted on.
Agents can build on it
- A flat, predictable API — no sprawling XAML or MVVM ceremony to reason about
- Every sample is one runnable file, checkable with
--frames N— an agent verifies its own work - Loud, immediate errors — fast feedback, no silent failure to debug blind
- Nothing hidden — an agent never gets stuck behind a closed abstraction
Apps are safe for agents to run
- Every action is attributed to an actor — a person, an AI, or an automation
- Capabilities and policy decide what is allowed before anything happens
- Sensitive actions surface an Allow / Allow once / Deny overlay to the user
- Built in and tested — not re-rolled, insecurely, in every app
Your AI pipeline, not ours.
Some frameworks are moving to own the whole AI loop — routing you through their model, their SDK, their interface. Skyline does not. Bring your own agent, your own model, your own pipeline. The framework's job is to give you fast, safe primitives — not to stand between you and the model you picked.
Every feature, in a sample you can run.
Clone the repo and run any sample in one command: dotnet run --project samples/<name>. Each one is a single self-contained file — which is the proof it works, and the reason an agent can build on Skyline. Pass --frames N to auto-close after N frames — the same way the smoke tests drive them.
Approvals
dotnet run --project samples/ApprovalsEvery action says who caused it — a person, an AI, an automation. When an actor asks for something sensitive (to type, take the keyboard, take control) the policy says "ask", and a composited overlay puts Allow / Allow once / Deny in front of you. A live grant lights an indicator in the corner.
TexturedQuad
dotnet run --project samples/TexturedQuadA full-screen WebGPU shader on top of FrameLoop: a slowly turning spiral galaxy. A full-screen triangle from the vertex index feeds one fragment shader — no vertex buffer, no texture — that paints the bright core, star-filled arms, and purple nebulae. The frame ritual — pace, acquire, clear, submit, present — belongs to the loop, so the file owns only the pipeline, its uniform, and the per-frame draw.
InteractiveCanvas
dotnet run --project samples/InteractiveCanvasDrag to paint. Pointer input turns into dynamic GPU geometry, re-uploaded only when it changes — and the loop idles when nothing moves instead of burning a core. Press C to clear.
TransparentWindow
macOS · dotnet run --project samples/TransparentWindowA see-through window: a transparent title bar with content drawn under it, and a clear-color alpha that lets the desktop show through. Drag the slider to change the transparency at runtime. Other platforms fall back to a GLFW transparent-framebuffer window.
UnifiedTitlebar
macOS · dotnet run --project samples/UnifiedTitlebarAn opaque window whose title bar merges into the content: the traffic lights float over the app and there is no separate top bar. The same merged-toolbar look as the transparent sample, on a solid window.
TwoWindows
dotnet run --project samples/TwoWindowsTwo windows, one GPU device, one render thread each. AppHost pumps events on the main thread while each window draws and presents on its own thread — so neither window's vsync wait can stall the other.
HelloWindow
dotnet run --project samples/HelloWindowThe whole stack end to end: a window, a clear pass, and a text overlay drawn with raw wgpu through Skyline.Gpu's escape hatches. Move the pointer to steer the clear color, press Space for a slow hue cycle, Escape to quit.
Open a window. Ship everywhere. Let agents build the rest.
agent-native · WebGPU-first · NativeAOT · the framework behind Starling
