Yotsuba Shader - Escribe shaders en C#

Escribe los shaders una vez. Compila para cualquier backend.

Escribe con el vocabulario que tu equipo conoce. Un frontend basado en Roslyn y una representación intermedia compartida lo convierten al formato de shader que espera cada API gráfica, como SPIR-V para Vulkan.

Pipeline de compilación previsto. La conversión de C# está incompleta; la salida WGSL está prevista para 2027.

ETAPAS DE SHADER

El pipeline de hoy. Las etapas que vienen después.

Vertex, Fragment y Compute están declarados en la API actual; su compilación completa está en desarrollo. Geometry, Hull y Domain están previstos para marzo de 2027.

Ahora

Vertex, Fragment, Compute

Las declaraciones de autoría existen actualmente. La compilación GPU completa sigue en desarrollo.

A triangle being rasterized into a grid of pixels — Diagrama de rasterización de Wojciech Mula, vía Wikimedia Commons · Dominio público

Marzo de 2027

Geometry, Hull, Domain

Soporte planificado para procesamiento de geometría y teselación en la GPU.

A tessellation pipeline turning a cube into a smooth shaded sphere — Diagrama de teselación de Romainbehar y Mark Viking, vía Wikimedia Commons · CC BY-SA 3.0

Octubre de 2027

4. Pipeline de ray tracing

Soporte planificado para los stages programables que hacen extensible el ray tracing.

Ray Generation
Intersection
Any-Hit
Closest-Hit
Miss
Callable

Rays traveling from a camera to a scene object and a light source — Diagrama de ray tracing de Henrik, vía Wikimedia Commons · CC BY-SA 4.0

Los sponsors ayudan a decidir qué viene después.

Yotsuba Shader es gratis para todos. El patrocinio paga el tiempo que lo mantiene vivo y te da voz sobre cómo se usa ese tiempo.

Patrocinar nunca desbloquea funciones ni cambia la licencia. Todos reciben el mismo código.

Conviértete en sponsor Ver todos los niveles

Etapas de vertex, fragment y compute, descritas en C# normal. Los tipos de vectores, matrices y texturas de tu proyecto se convierten en tipos nativos de la GPU, y tus shaders pueden apoyarse en bibliotecas externas: no hay un segundo lenguaje que aprender ni tipos duplicados. Si sabes escribir C#, sabes escribir shaders.

ExplorarPruébalo en el PlaygroundEmpieza con código de shader C# funcional. ValidarDetecta errores en tu IDEConsulta los límites actuales de validación y las comprobaciones previstas. DistribuyeCompila para cualquier backendUsa un único código de shader en todas las API gráficas.

Un shader. Cinco formas de escribirlo.

Cinco vocabularios de atributos describen conceptos de shaders en C#. Comparten una ruta de salida prevista; la conversión completa está en desarrollo y la salida WGSL sigue planificada.

Triangle.cs

using YotsubaShader.Language;
using YotsubaShader.HlslSyntax;
using YotsubaShader.HlslSyntax.Resources;

public struct VertexOutput
{
    [SV_Position]
    public Vector4 Position;
}

public class Triangle
{
    [register(RegisterPrefix.u, 0)]
    public RWStructuredBuffer<float> Output;

    [ShaderStage(Stage.Vertex)]
    public VertexOutput Vertex([SV_VertexID] uint id)
    {
        VertexOutput output = new VertexOutput();
        output.Position = new Vector4(0, 0, 0, 1);
        return output;
    }

    [ShaderStage(Stage.Fragment)]
    [return: SV_Target(0)]
    public Vector4 Fragment(VertexOutput input)
    {
        return new Vector4(1, 0.4f, 0.7f, 1);
    }

    [ShaderStage(Stage.Compute)]
    [numthreads(8, 8, 1)]
    public void Compute([SV_DispatchThreadID] UInt3 id)
    {
    }
}

Triangle.cs

using YotsubaShader.Language;
using YotsubaShader.GlslSyntax;
using YotsubaShader.GlslSyntax.Resources;

public struct VertexOutput
{
    [gl_Position]
    public Vector4 Position;
}

public class Triangle
{
    [buffer, layout(0, 0)]
    public float[] Output;

    [ShaderStage(Stage.Vertex)]
    public VertexOutput Vertex([gl_VertexIndex] uint id)
    {
        VertexOutput output = new VertexOutput();
        output.Position = new Vector4(0, 0, 0, 1);
        return output;
    }

    [ShaderStage(Stage.Fragment)]
    public Vector4 Fragment(VertexOutput input)
    {
        return new Vector4(1, 0.4f, 0.7f, 1);
    }

    [ShaderStage(Stage.Compute)]
    [layout_local_size(8, 8, 1)]
    public void Compute([gl_GlobalInvocationID] UInt3 id)
    {
    }
}

Triangle.cs

using YotsubaShader.Language;
using YotsubaShader.MslSyntax;
using YotsubaShader.MslSyntax.Resources;

public struct VertexOutput
{
    [position]
    public Vector4 Position;
}

public class Triangle
{
    [device, buffer(0)]
    public float[] Output;

    [ShaderStage(Stage.Vertex)]
    public VertexOutput Vertex([vertex_id] uint id)
    {
        VertexOutput output = new VertexOutput();
        output.Position = new Vector4(0, 0, 0, 1);
        return output;
    }

    [ShaderStage(Stage.Fragment)]
    public Vector4 Fragment(VertexOutput input)
    {
        return new Vector4(1, 0.4f, 0.7f, 1);
    }

    // El tamaño del workgroup lo define el host
    [ShaderStage(Stage.Compute)]
    public void Compute([thread_position_in_grid] UInt3 id)
    {
    }
}

Triangle.cs

using YotsubaShader.Language;
using YotsubaShader.SpirvSyntax;
using YotsubaShader.SpirvSyntax.Resources;

public struct VertexOutput
{
    [BuiltIn_Position]
    public Vector4 Position;
}

public class Triangle
{
    [StorageBuffer, DescriptorSet(0), @Binding(0)]
    public float[] Output;

    [ShaderStage(Stage.Vertex)]
    public VertexOutput Vertex([BuiltIn_VertexIndex] uint id)
    {
        VertexOutput output = new VertexOutput();
        output.Position = new Vector4(0, 0, 0, 1);
        return output;
    }

    [ShaderStage(Stage.Fragment)]
    public Vector4 Fragment(VertexOutput input)
    {
        return new Vector4(1, 0.4f, 0.7f, 1);
    }

    // El tamaño del workgroup lo define el host
    [ShaderStage(Stage.Compute)]
    public void Compute([BuiltIn_GlobalInvocationId] UInt3 id)
    {
    }
}

Triangle.cs

using YotsubaShader.Language;
using YotsubaShader.WgslSyntax;
using YotsubaShader.WgslSyntax.Resources;

public struct VertexOutput
{
    [@builtin_position]
    public Vector4 Position;
}

public class Triangle
{
    [storage(storage_use.read_write), @group(0), @binding(0)]
    public float[] Output;

    [ShaderStage(Stage.Vertex)]
    public VertexOutput Vertex([@builtin_vertex_index] uint id)
    {
        VertexOutput output = new VertexOutput();
        output.Position = new Vector4(0, 0, 0, 1);
        return output;
    }

    [ShaderStage(Stage.Fragment)]
    public Vector4 Fragment(VertexOutput input)
    {
        return new Vector4(1, 0.4f, 0.7f, 1);
    }

    [ShaderStage(Stage.Compute)]
    [@workgroup_size(8, 8, 1)]
    public void Compute([@builtin_global_invocation_id] UInt3 id)
    {
    }
}

Elegir una sintaxis

Diagnósticos de shaders: previstos

El playground ofrece actualmente diagnósticos C# y descubrimiento de shaders. Los diagnósticos de shaders en el IDE y el análisis de compatibilidad por backend están previstos.

Consulta el estado actual de validación

Integración con el build: en desarrollo

El generador existente construye la tabla de instrucciones SPIR-V. Están previstos un generador que compile tus shaders y una CLI de compilación de shaders.

Explora la generación binaria actual

Cada interfaz declarada. Validada antes de llegar a la GPU.

Entradas, salidas, recursos, ubicaciones, bindings y etapas se escriben con atributos, nunca se deducen por convenciones de nombres. Eso permite que el compilador revise un shader mucho antes de que lo vea cualquier controlador.

Ubicaciones y valores integrados en cada frontera entre etapas
Uniforms, storage buffers, texturas y samplers con bindings explícitos
Puntos de entrada de vertex, fragment y compute en una sola clase de C#

Slots de interfaz y ubicaciones

Interfaces.cs

using Microsoft.Xna.Framework;
using YotsubaShader.HlslSyntax;
using YotsubaShader.HlslSyntax.Resources;

public struct VertexOutput
{
    [SV_Position]
    public Vector4 Position;  // valor integrado

    [COLOR]
    public Vector4 Color;     // pasa a fragment
}

public sealed class Material
{
    [cbuffer, register(RegisterPrefix.b, 0)]
    public float Exposure;
}

Todo lo que necesita un shader, en C#.

Etapas Puntos de entrada de vertex, fragment y compute con [ShaderStage]. Más información Interfaces Ubicaciones y valores integrados entre etapas. Más información Recursos Uniforms, storage buffers, texturas y samplers. Más información Tipos nativos Escalares, vectores, matrices, arreglos y structs. Más información

Usa tus propios tipos. Trae tus propias bibliotecas.

Tus shaders forman parte de tu proyecto de C#, así que comparten sus tipos. Marca con un atributo los vectores, matrices y texturas que ya tienes y se convierten en tipos nativos de la GPU, sin un conjunto paralelo de structs solo para shaders que mantener sincronizado.

Asigna los tipos de CPU de tu proyecto a tipos nativos de la GPU con atributos
Crea shaders sobre bibliotecas externas y paquetes de NuGet
Un solo código para CPU y GPU: los mismos tipos en ambos lados

Reutilizar tus tipos y bibliotecas

Types.cs

// Tu propio tipo, como vector de la GPU
[Vector]
public struct Vector3
{
    [VectorComponent(0)] public float X;
    [VectorComponent(1)] public float Y;
    [VectorComponent(2)] public float Z;
}

// ...y usado directamente por un shader
[ShaderStage(Stage.Vertex)]
public VertexOutput Vertex(
    Vector3 position) { /* ... */ }

Un ecosistema portable de bibliotecas de shaders para tu framework o motor.

Los shaders son C# normal, así que una biblioteca de shaders es simplemente una biblioteca de .NET. Reutiliza tus propios tipos, usa las de otras personas y comparte las tuyas como paquete en NuGet, como cualquier otro código C#.

Empezar

Código abierto Gratis bajo la Microsoft Public License (MS-PL). Lee el repositorio, compílalo y contribuye. Más información Apoya el proyecto El patrocinio mantiene a Yotsuba Shader activo y gratuito para todos. Más información Únete a la comunidad Propón atributos, backends y shaders. Los cambios de diseño empiezan como un issue. Más información

Escribe Shaders en C#.

Escribe los shaders una vez. Compila para cualquier backend.

El pipeline de hoy. Las etapas que vienen después.

Vertex, Fragment, Compute

Geometry, Hull, Domain

4. Pipeline de ray tracing

Los sponsors ayudan a decidir qué viene después.

Un shader. Cinco formas de escribirlo.

Diagnósticos de shaders: previstos

Integración con el build: en desarrollo

Cada interfaz declarada. Validada antes de llegar a la GPU.

Todo lo que necesita un shader, en C#.

Usa tus propios tipos. Trae tus propias bibliotecas.

Un ecosistema portable de bibliotecas de shaders para tu framework o motor.

¿Listo para escribir tu primer shader?

Escribe Shaders en C#.

Escribe los shaders una vez. Compila para cualquier backend.

El pipeline de hoy. Las etapas que vienen después.

Vertex, Fragment, Compute

Geometry, Hull, Domain

4. Pipeline de ray tracing

Los sponsors ayudan a decidir qué viene después.

Da forma al roadmap

Sigue el trabajo

Gana visibilidad

Intégralo en tu motor

Un shader. Cinco formas de escribirlo.

Diagnósticos de shaders: previstos

Integración con el build: en desarrollo

Cada interfaz declarada. Validada antes de llegar a la GPU.

Todo lo que necesita un shader, en C#.

Usa tus propios tipos. Trae tus propias bibliotecas.

Un ecosistema portable de bibliotecas de shaders para tu framework o motor.

¿Listo para escribir tu primer shader?