DuoCode

The power of
Visual Studio

Enjoy the convenience of Visual Studio - the best IDE in the world, with state-of-the-art development and debugging experience.
More information

The power of
the C# language

Enjoy the power and convenience of C# 6.0 language, complete with strong-typing, class-based inheritance, reflection, generics, lambda expressions and LINQ.
See complete list

The power of
.NET Framework

Utilize the familiar classes in the standard libraries of the .NET Framework, including string manipulations, collections, and more.

The power of
DuoCode

Cross-compile C# code into readable and maintainable JavaScript.
Share code between Windows and JavaScript applications.
See code samples

Also featured in...

Compile C# code to JavaScript in Visual Studio

DuoCode is a fully-featured C# compiler, powered by Microsoft® Roslyn, and integrated in Visual Studio.

It cross-compiles your C# 6.0 code into high-quality readable JavaScript code, enabling rapid development of web applications utilizing the extensive features of the C# language, the Visual Studio IDE, and the .NET Framework base class libraries.

Development in C# with Visual Studio brings great productivity wins, thanks to strong-typing, code completion, compile-time error checking, static analysis, code navigation and refactoring, as well as the new Roslyn-powered diagnostic live-code analyzers.

Develop HTML5 applications using strongly-typed and documented class-definitions of the entire DOM class library (including HTML, CSS, SVG and WebGL definitions).

See code samples

Features supported in DuoCode

C# language features

C# Classes

With inheritance, virtual methods, base calls, abstract and static classes

public sealed class Student : Person
{
    public Student(string name, int id) : base(name)
    {
      ...
    }

    public override ToString()
    {
        return base.ToString() + " " + id;
    }

    public override int GetGrades() { ... };
}

Method overloading

Support for method overloading

public void WriteLine();
public void WriteLine(string value);
public void WriteLine(bool value);
public void WriteLine(int value, string format);

Properties

Including get-only and set-only, indexers and modifiers

string this[int index] { get { return items[index].ToString(); }
int ID { get; private set; }

Interfaces

With multiple inheritance, casting

public interface IStudent : IPerson, IComparable<IStudent> { }
...
var isStudnet = person is IStudent;

Generics

Generic classes, interfaces and methods with generic constraints

public class Bag<T> where T: IComparable<T>
{
    private readonly HashSet<T> items;
    public bool IsSame<U>(U key)
    {
        ...

Integral types

All of C# integral types, including int, double, float, string, char, bool, uint, short, byte and more

string name = "James" + ' ' + id.ToString();
char initials = name[0];
int length = name.Length;

Events and delegates

delegate TResult Func2(T1 arg1, T2 arg2);
...
sink.OnNotify += Listener_OnNotify;
Func<double, bool> func = IsPrime;
Func<string> lambda = () => { return "foo"; };

Lambda expressions

Student james = Array.Find(students, s => s.Name == "James");
var func = n => { string s = n + " " + "World"; Console.WriteLine(s); };

Arrays

Including multi-dimensional arrays

string[] names = new[] { "Alice", "Bob", "Charly" };
int[,] values = new int[10,10];

Structs

Read-only (immutable) structures are recommended for optimized performance

public struct Point
{
  public readonly static Point Zero = new Point(0, 0);

  public readonly int X;
  public readonly int Y;

  public Point(int x, int y)
  {
    X = x;
    Y = y;
  }
}

ForEach, Enumerators, Yield

Enums

Including [Flags], boxing and parsing

enum Fruits
{
  Apple,
  Banana = 1,
  Orange = Apple | Banana
}
int value = (int)Fruits.Banana;
Console.WriteLine(Fruits.Apple.ToString());
var obj = Enum.Parse(typeof(Fruits), "Orange");

Loops

Reflection

Including assemblies, attributes, types, methods, properties, fields, events and parameters

Assembly assembly = Assembly.GetExecutingAssembly();
foreach (Type type in assembly.GetTypes())
{
  foreach (MethodInfo currentMethod in type.GetMethods())
  {
    if (currentMethod.GetCustomAttributes(typeof(TestAttribute), false).Count > 0)
    {
      var instance = type.GetConstructors()[0].Invoke(new object[0]);
      currentMethod.Invoke(instance, new object[0]);
    }
  }
}

Dynamic binding

Easy access to JavaScript using dynamic keyword

// dynamic access
dynamic doc = Js.referenceAs<dynamic>("document");
string innerText = doc.body.firstElementChild.innerText as string;

// typed access using DOM definitions
using static DuoCode.Dom.Global;
...
string innerText = document.body.firstElementChild.innerText;

Nullable types

Optimized nullable types support

int? i = 5;
if (i.HasValue)
  Console.WriteLine("i = " + i.Value);

short? j = null;
short zero = j.GetValueOrDefault();
try
{
    short q = j.Value; // j is null
}
catch (InvalidOperationException e)
{
    Console.WriteLine(e.Message);
}

Ref and Out

public bool TryParse(string text, out int value)

Params

public static string Format(string format, params object[] args)

Optional arguments

public bool TryParse(string text, out int value, CultureInfo cultureInfo = null)

Extension methods

Attributes

Associate custom attributes with types, method or parameters

[TestFixture]
public class MyTests
{
    [Test]
    public void Foo()
    {
        var attributes = typeof(MyTests).GetMethods("Foo").GetCustomAttributes();
    }
}

Operator overloading

Casting

Including is, as, typeof, implicit/explicit casting, interfaces, covariance and external types

var intArray = new int[] { 1, 2, 3 };
Array objArray = intArray;
IList list1 = objArray as IList;
IList list2 = (IList)objArray;
IList<int> list3 = objArray as IList<int>;
...
bool bTrue1  = typeof(Delegate[,]).IsAssignableFrom(typeof(Action[,])); // covariance
bool bTrue2  = typeof(Dom.UIEvent).IsAssignableFrom(typeof(Dom.KeyboardEvent));
bool bFalse1 = typeof(int).IsAssignableFrom(typeof(int?)); // int? to int cast

Async and Await

Exceptions

Collections

LINQ

public static IEnumerable Foo()
{
    return Enumerable.Range(0, 10).Where(x => x % 2 == 0).Select(x => x * 3);
}

Integer arithmetic

Support for integer arithmetic, wrapping, and bitwise operations

int intValue = 10 / 3; // equals 3
double doubleValue = 10d / 3; // equals 3.3333...
int mask = byte.MaxValue & 0x0F; // low nibble
byte value = (byte)257; // equals 1

Conditional operator (?:)

string classify = (input > 0) ? "positive" : "negative";

Null-coalescing operator (??)

Returns the left-hand operand if the operand is not null; otherwise it returns the right hand operand

string name = _name ?? "Default";
int? nullableInt = null;
int id = nullableInt ?? 0;

Checked operations

Support for checked/unchecked numeric operations

int int257 = 257;
checked
{
  byte byte1 = unchecked((byte)int257); // equals 1
  byte byte2 = (byte)int257; // throws OverflowException
}

C# 6.0

nameof

Support for nameof expression

throw new ExceptionArgument(id, nameof(id));

Expression-methods

Support for expression-bodied function members

public Point Move(int dx, int dy) => new Point(x + dx, y + dy);
public void Print() => Console.WriteLine(First + " " + Last);

Expression-properties

Support for expression-bodied properties

public string Name => First + " " + Last;

Auto-property initializers

Support for auto-property initializers

public class Customer
{
    public string First { get; } = "Jane";
    public string Last { get; set; } = "Doe";
}

Exception filters

Support for exception filters

try { … }
catch (MyException e) when (e.Message == "some error")
{
   ...
}

using static

Support for using static to import static members of types directly into scope

using static System.Console;
using static System.Math;
using static DuoCode.Dom.Global;

class Program
{
    static void Main()
    {
        WriteLine(Sqrt(3*3 + 4*4));
        WriteLine(navigator.userAgent);
    }
}

String interpolation

Support for string interpolation

// C# 6.0 string interpolation
var s1 = $"{p.Name,20} is {p.Age:D3} years old";

// classic string-format
var s2 = String.Format("{0} is {1} years old", p.Name, p.Age);

Null-conditional operators

Support for null-conditional operators '?.'

int? length = customers?.Length; // null if customers is null
Customer first = customers?[0];  // null if customers is null

int length = customers?.Length ?? 0; // 0 if customers is null

if (predicate?.Invoke(e) == true) { … } // safe delegate invocation

PropertyChanged?.Invoke(this, args); //  triggering of events

Index initializers

Support for index in collection initializers and extension Add methods

var numbers = new Dictionary {
    [7] = "seven",
    [9] = "nine",
    [13] = "thirteen"
};

More features

TypeScript

Automatic generation of TypeScript declaration files (.d.ts) with support for ECMAScript 3/5/6

/// <reference path="./mscorlib.d.ts" />

declare module TypeScriptHtmlApp {
    // TypeScriptHtmlApp.RomanUtils
    export interface RomanUtilsTypeFunc extends TypeFunction {
        ConvertNumberToRoman(number: int): string;
        ConvertRomanToNumber(text: string): int;
    }
    var RomanUtils: RomanUtilsTypeFunc;
}

Hybrid C# / TypeScript projects

Allows creating hybrid C# / TypeScript applications in a single project

Strongly-typed DOM/HTML5

Complete type-definitions for DOM objects, with strong-typing and inline documentation

using static DuoCode.Dom;
...
string userAgent = navigator.userAgent;
HTMLScriptElement script = (HTMLScriptElement)document.getElementById(scriptId);
var timerToken = window.setInterval((Action)Tick, 500);

// alternative dynamic access
dynamic doc = Js.referenceAs<dynamic>("document");
string innerText = doc.getElementById(scriptId).innerText as string;

Strongly-typed WebGL

Complete type-definitions for WebGL objects, with strong-typing and inline documentation

using DuoCode.Dom;
...
WebGLRenderingContext gl = canvas.getContext("webgl");

gl.bindBuffer(GL.ARRAY_BUFFER, bCubeTextureCoords);
gl.vertexAttribPointer(aTextureCoord, 2, GL.FLOAT, false, 0, 0);

gl.activeTexture(GL.TEXTURE0);
gl.bindTexture(GL.TEXTURE_2D, texture);
gl.uniform1i(uSampler, 0);

gl.drawElements(GL.TRIANGLES, CubeData.Indices.Length, GL.UNSIGNED_SHORT, 0);

Resource embedding

Resource files are automatically encoded and embedded into JS assembly file

HTMLImageElement imageElement = Properties.Resources.duocode.Image;

string text = Assembly.GetExecutingAssembly().GetManifestResourceString("resource.txt");

Mono / XBuild support

Continuous Integration (CI) ready

Typed arrays

Arrays are automatically translated to JS typed-arrays when possible, for performance gains

// C#
float[] numbers = new float[20];
byte[] buffer = new byte[1024];

// JavaScript
var numbers = new Float32Array(20);
var buffer = new Uint8Array(1024);

JSDoc generation

Automatically generate JSDoc comments based on C# XML comments and type information

/**
 * Replaces the format item in a specified string...
 * @this {string}
 * @public
 * @param {string} format A composite format string (see Remarks).
 * @param {object[]} args An object array that contains zero or more objects to format.
 * @return {string} A copy of {@link format} in which the format items...
 * @throws {T:System.ArgumentNullException} {@link format} or {@link args} is null.
 * @throws {T:System.FormatException} {@link format} is invalid.
 */
 String.Format = function String_Format(format, args) {
 ...
 }

AMD, CommonJS and UMD

Closure-friendly output

Roslyn diagnostic analyzers

Web Workers

Compiler services

Support for advanced System.Runtime.CompilerServices attributes

public void WriteCallerArguments([CallerFilePath  ] string callerFilePath = null,
                                 [CallerLineNumber] int    callerLineNumber = 0,
                                 [CallerMemberName] string callerMemberName = null)
{
  Console.WriteLine($"{callerFilePath}:{callerLineNumber} {callerMemberName}()");
}

Visual Studio integration

Project templates

Debugging (VS2013 and above )

Project property page

NuGet support

MSBuild support

Resource editor

Shared projects support

Web publishing (Azure)

Amazing C# debugging

DuoCode automatically generates source mappings, which allow you to view and debug the original C# source files directly inside the browser or in Visual Studio 2013, 2015 or 2017.

This groundbreaking feature enables full C# debugging using the browser's built-in developing tools, including source stepping, breakpoints, watches and complete C# call-stack.

Experience it yourself - try it live in your browser!

DuoCode

Magic

C#

using System;
using DuoCode.Dom;
using static DuoCode.Dom.Global; // C# 6.0 'using static' syntax

namespace HelloDuoCode
{
  public class Greeter
  {
    private readonly HTMLElement element;
    private readonly HTMLElement span;
    private int timerToken;

    public Greeter(HTMLElement el)
    {
      element = el;
      span = document.createElement("span");
      element.appendChild(span);
      Tick();
    }

    public void Start()
    {
      timerToken = window.setInterval((Action)Tick, 500);
    }

    public void Stop()
    {
      window.clearTimeout(timerToken);
    }

    private void Tick()
    {
      span.innerHTML = string.Format("The time is: {0}", DateTime.Now);
    }
  }

  static class Program
  {
    static void Run()
    {
      System.Console.WriteLine("Hello DuoCode");

      var el = document.getElementById("content");
      var greeter = new Greeter(el);
      greeter.Start();
    }
  }
}

JavaScript

var HelloDuoCode = this.HelloDuoCode || {};
var $d = DuoCode.Runtime;
HelloDuoCode.Greeter = $d.declare("HelloDuoCode.Greeter", System.Object, 0, $asm, function($t, $p) {
    $t.$ator = function() {
        this.element = null;
        this.span = null;
        this.timerToken = 0;
    };
    $t.ctor = function Greeter(el) {
        $t.$baseType.ctor.call(this);
        this.element = el;
        this.span = document.createElement("span");
        this.element.appendChild(this.span);
        this.Tick();
    };
    $t.ctor.prototype = $p;
    $p.Start = function Greeter_Start() {
        this.timerToken = window.setInterval($d.delegate(this.Tick, this), 500);
    };
    $p.Stop = function Greeter_Stop() {
        window.clearTimeout(this.timerToken);
    };
    $p.Tick = function Greeter_Tick() {
        this.span.innerHTML = String.Format("The time is: {0}", $d.array(System.Object, [System.DateTime().get_Now()]));
    };
});
HelloDuoCode.Program = $d.declare("HelloDuoCode.Program", System.Object, 0, $asm, function($t, $p) {
    $t.Run = function Program_Run() {
        System.Console.WriteLine$10("Hello DuoCode");

        var el = document.getElementById("content");
        var greeter = new HelloDuoCode.Greeter.ctor(el);
        greeter.Start();
    };
});

C#

using DuoCode.Dom;
using System;

namespace WebGL
{
  using GL = WebGLRenderingContext;

  internal static class Utils
  {
    public static WebGLRenderingContext CreateWebGL(HTMLCanvasElement canvas)
    {
      WebGLRenderingContext result = null;
      string[] names = { "webgl", "experimental-webgl", "webkit-3d", "moz-webgl" };
      foreach (string name in names)
      {
        try
        {
          result = canvas.getContext(name);
        }
        catch { }
        if (result != null)
          break;
      }
      return result;
    }

    public static WebGLShader CreateShaderFromScriptElement(WebGLRenderingContext gl, string scriptId)
    {
      var shaderScript = (HTMLScriptElement)Global.document.getElementById(scriptId);

      if (shaderScript == null)
        throw new Exception("unknown script element " + scriptId);

      string shaderSource = shaderScript.text;

      // Now figure out what type of shader script we have, based on its MIME type
      int shaderType = (shaderScript.type == "x-shader/x-fragment") ? GL.FRAGMENT_SHADER :
                       (shaderScript.type == "x-shader/x-vertex")   ? GL.VERTEX_SHADER   : 0;
      if (shaderType == 0)
        throw new Exception("unknown shader type");

      WebGLShader shader = gl.createShader(shaderType);
      gl.shaderSource(shader, shaderSource);

      // Compile the shader program
      gl.compileShader(shader);

      // See if it compiled successfully
      if (!gl.getShaderParameter(shader, GL.COMPILE_STATUS))
      {
        // Something went wrong during compilation; get the error
        var errorInfo = gl.getShaderInfoLog(shader);
        gl.deleteShader(shader);
        throw new Exception("error compiling shader '" + shader + "': " + errorInfo);
      }
      return shader;
    }

    public static WebGLProgram CreateShaderProgram(WebGLRenderingContext gl, WebGLShader fragmentShader, WebGLShader vertexShader)
    {
      var shaderProgram = gl.createProgram();
      gl.attachShader(shaderProgram, vertexShader);
      gl.attachShader(shaderProgram, fragmentShader);
      gl.linkProgram(shaderProgram);

      bool linkStatus = gl.getProgramParameter(shaderProgram, GL.LINK_STATUS);
      if (!linkStatus)
        throw new Exception("failed to link shader");
      return shaderProgram;
    }

    public static WebGLTexture LoadTexture(WebGLRenderingContext gl, string resourceName)
    {
      var result = gl.createTexture();
      var imageElement = Properties.Resources.duocode.Image;
      imageElement.onload = new Func<Event, dynamic>((e) =>
      {
        UploadTexture(gl, result, imageElement);
        return true;
      });

      return result;
    }

    public static void UploadTexture(WebGLRenderingContext gl, WebGLTexture texture, HTMLImageElement imageElement)
    {
      gl.pixelStorei(GL.UNPACK_FLIP_Y_WEBGL, GL.ONE);
      gl.bindTexture(GL.TEXTURE_2D, texture);
      gl.texImage2D(GL.TEXTURE_2D, 0, GL.RGBA, GL.RGBA, GL.UNSIGNED_BYTE, imageElement);
      gl.texParameteri(GL.TEXTURE_2D, GL.TEXTURE_MAG_FILTER, GL.LINEAR);
      gl.texParameteri(GL.TEXTURE_2D, GL.TEXTURE_MIN_FILTER, GL.LINEAR_MIPMAP_NEAREST);
      gl.generateMipmap(GL.TEXTURE_2D);
      gl.bindTexture(GL.TEXTURE_2D, null);
    }

    public static float DegToRad(float degrees)
    {
      return (float)(degrees * System.Math.PI / 180);
    }
  }
}

JavaScript

WebGL.Utils = $d.declare("WebGL.Utils", System.Object, 0, $asm, function($t, $p) {
    $t.CreateWebGL = function Utils_CreateWebGL(canvas) {
        var result = null;
        var names = $d.array(String, ["webgl", "experimental-webgl", "webkit-3d", "moz-webgl"]);
        for (var $i = 0, $length = names.length; $i != $length; $i++) {
            var name = names[$i];
            try {
                result = canvas.getContext(name);
            }
            catch ($e) {}

            if (result != null)
                break;
        }
        return result;
    };
    $t.CreateShaderFromScriptElement = function Utils_CreateShaderFromScriptElement(gl, scriptId) {
        var shaderScript = $d.cast(document.getElementById(scriptId), HTMLScriptElement);

        if (shaderScript == null)
            throw new System.Exception.ctor$1("unknown script element " + scriptId);

        var shaderSource = shaderScript.text;

        // Now figure out what type of shader script we have, based on its MIME type
        var shaderType = (shaderScript.type == "x-shader/x-fragment") ? 35632 /* WebGLRenderingContext.FRAGMENT_SHADER */ : (shaderScript.type == "x-shader/x-vertex") ? 35633 /* WebGLRenderingContext.VERTEX_SHADER */ : 0;
        if (shaderType == 0)
            throw new System.Exception.ctor$1("unknown shader type");

        var shader = gl.createShader(shaderType);
        gl.shaderSource(shader, shaderSource);

        // Compile the shader program
        gl.compileShader(shader);

        // See if it compiled successfully
        if (!gl.getShaderParameter(shader, 35713 /* WebGLRenderingContext.COMPILE_STATUS */)) {
            // Something went wrong during compilation; get the error
            var errorInfo = gl.getShaderInfoLog(shader);
            gl.deleteShader(shader);
            throw new System.Exception.ctor$1("error compiling shader '" + $d.toString(shader) + "': " + errorInfo);
        }
        return shader;
    };
    $t.CreateShaderProgram = function Utils_CreateShaderProgram(gl, fragmentShader, vertexShader) {
        var shaderProgram = gl.createProgram();
        gl.attachShader(shaderProgram, vertexShader);
        gl.attachShader(shaderProgram, fragmentShader);
        gl.linkProgram(shaderProgram);

        var linkStatus = gl.getProgramParameter(shaderProgram, 35714 /* WebGLRenderingContext.LINK_STATUS */);
        if (!linkStatus)
            throw new System.Exception.ctor$1("failed to link shader");
        return shaderProgram;
    };
    $t.LoadTexture = function Utils_LoadTexture(gl, resourceName) {
        var result = gl.createTexture();
        var imageElement = WebGL.Properties.Resources().get_duocode().Image;
        imageElement.onload = $d.delegate(function(e) {
            WebGL.Utils.UploadTexture(gl, result, imageElement);
            return true;
        }, this);

        return result;
    };
    $t.UploadTexture = function Utils_UploadTexture(gl, texture, imageElement) {
        gl.pixelStorei(37440 /* WebGLRenderingContext.UNPACK_FLIP_Y_WEBGL */, 1 /* WebGLRenderingContext.ONE */);
        gl.bindTexture(3553 /* WebGLRenderingContext.TEXTURE_2D */, texture);
        gl.texImage2D(3553 /* WebGLRenderingContext.TEXTURE_2D */, 0, 6408 /* WebGLRenderingContext.RGBA */, 6408 /* WebGLRenderingContext.RGBA */, 5121 /* WebGLRenderingContext.UNSIGNED_BYTE */, imageElement);
        gl.texParameteri(3553 /* WebGLRenderingContext.TEXTURE_2D */, 10240 /* WebGLRenderingContext.TEXTURE_MAG_FILTER */, 9729 /* WebGLRenderingContext.LINEAR */);
        gl.texParameteri(3553 /* WebGLRenderingContext.TEXTURE_2D */, 10241 /* WebGLRenderingContext.TEXTURE_MIN_FILTER */, 9985 /* WebGLRenderingContext.LINEAR_MIPMAP_NEAREST */);
        gl.generateMipmap(3553 /* WebGLRenderingContext.TEXTURE_2D */);
        gl.bindTexture(3553 /* WebGLRenderingContext.TEXTURE_2D */, null);
    };
    $t.DegToRad = function Utils_DegToRad(degrees) {
        return (degrees * 3.14159265358979 /* Math.PI */ / 180);
    };
});

C#

using System;
using Dom = DuoCode.Dom;

namespace RayTracer
{
  struct Vector
  {
    public readonly double x;
    public readonly double y;
    public readonly double z;

    public Vector(double x, double y, double z)
    {
      this.x = x;
      this.y = y;
      this.z = z;
    }

    public static Vector operator *(double k, Vector v)
    {
      return new Vector(k * v.x, k * v.y, k * v.z);
    }

    public static Vector operator -(Vector v1, Vector v2)
    {
      return new Vector(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
    }

    public static Vector operator +(Vector v1, Vector v2)
    {
      return new Vector(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
    }

    public static double dot(Vector v1, Vector v2)
    {
      return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
    }

    public static double mag(Vector v)
    {
      return Math.Sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
    }

    public static Vector norm(Vector v)
    {
      double mag = Vector.mag(v);
      double div = (mag == 0) ? double.PositiveInfinity : 1.0 / mag;
      return div * v;
    }

    public static Vector cross(Vector v1, Vector v2)
    {
      return new Vector(v1.y * v2.z - v1.z * v2.y,
                        v1.z * v2.x - v1.x * v2.z,
                        v1.x * v2.y - v1.y * v2.x);
    }
  }

  struct Color
  {
    public readonly double r;
    public readonly double g;
    public readonly double b;

    public Color(double r, double g, double b)
    {
      this.r = r;
      this.g = g;
      this.b = b;
    }

    public static Color operator *(double k, Color v)
    {
      return new Color(k * v.r, k * v.g, k * v.b);
    }

    public static Color operator +(Color v1, Color v2)
    {
      return new Color(v1.r + v2.r, v1.g + v2.g, v1.b + v2.b);
    }

    public static Color operator *(Color v1, Color v2)
    {
      return new Color(v1.r * v2.r, v1.g * v2.g, v1.b * v2.b);
    }

    public static Color white = new Color(1.0, 1.0, 1.0);
    public static Color grey  = new Color(0.5, 0.5, 0.5);
    public static Color black = new Color(0.0, 0.0, 0.0);
    public static Color background   = Color.black;
    public static Color defaultColor = Color.black;

    private int ToByte(double value)
    {
      value = value > 1 ? 1 : value;
      return (int)Math.Floor(value * 255);
    }

    public override string ToString()
    {
      return string.Format("rgb({0},{1},{2})", ToByte(r), ToByte(g), ToByte(b));
    }
  }

  class Camera
  {
    public readonly Vector forward;
    public readonly Vector right;
    public readonly Vector up;
    public readonly Vector pos;
    public readonly Vector lookAt;

    public Camera(Vector pos, Vector lookAt)
    {
      this.pos = pos;
      this.lookAt = lookAt;
      Vector down = new Vector(0.0, -1.0, 0.0);
      this.forward = Vector.norm(lookAt - pos);
      this.right = 1.5 * Vector.norm(Vector.cross(this.forward, down));
      this.up    = 1.5 * Vector.norm(Vector.cross(this.forward, this.right));
    }
  }

  class Ray
  {
    public readonly Vector start;
    public readonly Vector dir;
    public Ray(Vector start, Vector dir)
    {
      this.start = start;
      this.dir = dir;
    }
  }

  class Intersection
  {
    public readonly IThing  thing;
    public readonly Ray    ray;
    public readonly double dist;
    public Intersection(IThing thing, Ray ray, double dist)
    {
      this.thing = thing;
      this.ray = ray;
      this.dist = dist;
    }
  }

  class Surface
  {
    public readonly Func<Vector, Color> diffuse;
    public readonly Func<Vector, Color> specular;
    public readonly Func<Vector, double> reflect;
    public readonly double roughness;
    public Surface(Func<Vector, Color> diffuse, Func<Vector, Color> specular, Func<Vector, double> reflect, double roughness)
    {
      this.diffuse = diffuse;
      this.specular = specular;
      this.reflect = reflect;
      this.roughness = roughness;
    }
  }

  interface IThing
  {
    Intersection intersect(Ray ray);
    Vector normal(Vector pos);
    Surface surface { get; }
  }

  class Light
  {
    public readonly Vector pos;
    public readonly Color color;
    public Light(Vector pos, Color color)
    {
      this.pos = pos;
      this.color = color;
    }
  }

  class Scene
  {
    public readonly IThing[] things;
    public readonly Light[] lights;
    public readonly Camera  camera;
    public Scene(IThing[] things, Light[] lights, Camera camera)
    {
      this.things = things;
      this.lights = lights;
      this.camera = camera;
    }
  }

  class Sphere : IThing
  {
    private readonly Vector  center;
    private readonly double  radius2;
    private readonly Surface surface;

    public Sphere(Vector center, double radius, Surface surface)
    {
      this.center = center;
      this.surface = surface;
      this.radius2 = radius * radius;
    }

    public Vector normal(Vector pos)
    {
      return Vector.norm(pos - this.center);
    }

    Surface IThing.surface
    {
      get { return this.surface; }
    }

    public Intersection intersect(Ray ray)
    {
      var eo = this.center - ray.start;
      var v = Vector.dot(eo, ray.dir);
      var dist = 0d;
      if (v >= 0)
      {
        var disc = this.radius2 - (Vector.dot(eo, eo) - v * v);
        if (disc >= 0)
        {
          dist = v - Math.Sqrt(disc);
        }
      }

      if (dist == 0)
        return null;
      else
        return new Intersection(this, ray, dist);
    }
  }

  class Plane : IThing
  {
    private readonly Vector norm;
    private readonly Surface surface;
    private readonly double offset;

    public Plane(Vector norm, double offset, Surface surface)
    {
      this.norm = norm;
      this.offset = offset;
      this.surface = surface;
    }

    public Intersection intersect(Ray ray)
    {
      Intersection result = null;

      var denom = Vector.dot(norm, ray.dir);
      if (denom <= 0)
      {
        var dist = (Vector.dot(norm, ray.start) + offset) / (-denom);
        result = new Intersection(this, ray, dist);
      }

      return result;
    }

    public Vector normal(Vector pos)
    {
      return norm;
    }

    Surface IThing.surface
    {
      get { return this.surface; }
    }
  }

  static class Surfaces
  {
    public static Surface shiny = new Surface(
      diffuse:  (pos) => Color.white,
      specular: (pos) => Color.grey,
      reflect:  (pos) => 0.7,
      roughness: 250);

    public static Surface checkerboard = new Surface(
      diffuse:  (pos) => ((Math.Floor(pos.z) + Math.Floor(pos.x)) % 2 != 0) ? Color.white : Color.black,
      specular: (pos) => Color.white,
      reflect:  (pos) => ((Math.Floor(pos.z) + Math.Floor(pos.x)) % 2 != 0) ? 0.1 : 0.7,
      roughness: 150);
  }

  static class RayTracer
  {
    private const int maxDepth = 5;

    private static Intersection intersections(Ray ray, Scene scene)
    {
      double closest = double.PositiveInfinity;
      Intersection closestInter = null;

      foreach (var thing in scene.things)
      {
        var inter = thing.intersect(ray);
        if (inter != null && inter.dist < closest)
        {
          closestInter = inter;
          closest = inter.dist;
        }
      }

      return closestInter;
    }

    private static double testRay(Ray ray, Scene scene)
    {
      Intersection isect = intersections(ray, scene);

      return (isect != null) ? isect.dist : double.NaN;
    }

    private static Color traceRay(Ray ray, Scene scene, int depth)
    {
      var isect = intersections(ray, scene);

      return isect == null ? Color.background : shade(isect, scene, depth);
    }

    private static Color shade(Intersection isect, Scene scene, int depth)
    {
      var d = isect.ray.dir;
      var pos = isect.dist * d + isect.ray.start;
      var normal = isect.thing.normal(pos);
      var reflectDir = d - (2 * Vector.dot(normal, d) * normal);

      var naturalColor = Color.background + getNaturalColor(isect.thing, pos, normal, reflectDir, scene);
      var reflectedColor = (depth >= maxDepth) ? Color.grey : getReflectionColor(isect.thing, pos, normal, reflectDir, scene, depth);
      return naturalColor + reflectedColor;
    }

    private static Color getReflectionColor(IThing thing, Vector pos, Vector normal, Vector rd, Scene scene, int depth)
    {
      return thing.surface.reflect(pos) * traceRay(new Ray(pos, rd), scene, depth + 1);
    }

    private static Color getNaturalColor(IThing thing, Vector pos, Vector norm, Vector rd, Scene scene)
    {
      Color result = Color.defaultColor;
      foreach (Light light in scene.lights)
      {
        var ldis = light.pos - pos;
        var livec = Vector.norm(ldis);
        var neatIsect = testRay(new Ray(pos, livec), scene);
        var isInShadow = !double.IsNaN(neatIsect) && (neatIsect <= Vector.mag(ldis));

        if (isInShadow)
          continue;

        var illum = Vector.dot(livec, norm);
        var lcolor = (illum > 0) ? illum * light.color : Color.defaultColor;
        var specular = Vector.dot(livec, Vector.norm(rd));
        var scolor = (specular > 0) ? Math.Pow(specular, thing.surface.roughness) * light.color : Color.defaultColor;

        result = result + thing.surface.diffuse(pos) * lcolor + thing.surface.specular(pos) * scolor;
      }

      return result;
    }

    public static void render(Scene scene, Dom.CanvasRenderingContext2D ctx, int screenWidth, int screenHeight)
    {
      Camera camera = scene.camera;

      for (int y = 0; y < screenHeight; y++)
        for (int x = 0; x < screenWidth; x++)
        {
          double recenterX = (x - (screenWidth / 2.0)) / 2.0 / screenWidth;
          double recenterY = -(y - (screenHeight / 2.0)) / 2.0 / screenHeight;
          Vector dir = Vector.norm(camera.forward + (recenterX * camera.right) + (recenterY * camera.up));

          Color color = traceRay(new Ray(camera.pos, dir), scene, 0);

          ctx.fillStyle = color.ToString();
          ctx.fillRect(x, y, x + 1, y + 1);
        }
    }
  }

  static class Program
  {
    static void Run() // HTML body.onload event entry point, see index.html
    {
      Scene defaultScene = new Scene(
        things: new IThing[]
        {
          new Plane(new Vector(0.0, 1.0, 0.0), 0.0, Surfaces.checkerboard),
          new Sphere(new Vector(0.0, 1.0, -0.25), 1.0, Surfaces.shiny),
          new Sphere(new Vector(-1.0, 0.5, 1.5), 0.5, Surfaces.shiny)
        },
        lights: new[]
        {
          new Light(new Vector(-2.0, 2.5, 0.0), new Color(0.49, 0.07, 0.07)),
          new Light(new Vector(1.5, 2.5, 1.5),  new Color(0.07, 0.07, 0.49)),
          new Light(new Vector(1.5, 2.5, -1.5), new Color(0.07, 0.49, 0.071)),
          new Light(new Vector(0.0, 3.5, 0.0),  new Color(0.21, 0.21, 0.35))
        },
        camera: new Camera(new Vector(3.0, 2.0, 4.0), new Vector(-1.0, 0.5, 0.0))
      );

      var canvas = Dom.Global.document.createElement("canvas");
      canvas.width  = 256;
      canvas.height = 256;
      Dom.Global.document.body.appendChild(canvas);
      var ctx = canvas.getContext("2d");
      int ticks = Environment.TickCount;

      RayTracer.render(defaultScene, ctx, 256, 256);

      ticks = Environment.TickCount - ticks;
      System.Console.WriteLine("render time: " + ticks + " ms");
    }
  }
}

JavaScript

var RayTracer = this.RayTracer || {};
var $d = DuoCode.Runtime;
RayTracer.Vector = $d.declare("RayTracer.Vector", null, 62, $asm, function($t, $p) {
    $t.ctor = function Vector() {
        this.x = 0;
        this.y = 0;
        this.z = 0;
    };
    $t.ctor.prototype = $p;
    $t.ctor$1 = function Vector(x, y, z) {
        this.x = x;
        this.y = y;
        this.z = z;
    };
    $t.ctor$1.prototype = $p;
    $t.op_Multiply = function Vector_op_Multiply(k, v) {
        return new RayTracer.Vector.ctor$1(k * v.x, k * v.y, k * v.z);
    };
    $t.op_Subtraction = function Vector_op_Subtraction(v1, v2) {
        return new RayTracer.Vector.ctor$1(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
    };
    $t.op_Addition = function Vector_op_Addition(v1, v2) {
        return new RayTracer.Vector.ctor$1(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
    };
    $t.dot = function Vector_dot(v1, v2) {
        return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
    };
    $t.mag = function Vector_mag(v) {
        return System.Math.Sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
    };
    $t.norm = function Vector_norm(v) {
        var mag = RayTracer.Vector.mag(v);
        var div = (mag == 0) ? Infinity /* Double.PositiveInfinity */ : 1 / mag;
        return RayTracer.Vector.op_Multiply(div, v);
    };
    $t.cross = function Vector_cross(v1, v2) {
        return new RayTracer.Vector.ctor$1(v1.y * v2.z - v1.z * v2.y, v1.z * v2.x - v1.x * v2.z, v1.x * v2.y - v1.y * v2.x);
    };
});
RayTracer.Color = $d.declare("RayTracer.Color", null, 62, $asm, function($t, $p) {
    $t.cctor = function() {
        $t.white = new RayTracer.Color.ctor$1(1, 1, 1);
        $t.grey = new RayTracer.Color.ctor$1(0.5, 0.5, 0.5);
        $t.black = new RayTracer.Color.ctor$1(0, 0, 0);
        $t.background = RayTracer.Color().black;
        $t.defaultColor = RayTracer.Color().black;
    };
    $t.ctor = function Color() {
        this.r = 0;
        this.g = 0;
        this.b = 0;
    };
    $t.ctor.prototype = $p;
    $t.ctor$1 = function Color(r, g, b) {
        this.r = r;
        this.g = g;
        this.b = b;
    };
    $t.ctor$1.prototype = $p;
    $t.op_Multiply$1 = function Color_op_Multiply$1(k, v) {
        return new RayTracer.Color.ctor$1(k * v.r, k * v.g, k * v.b);
    };
    $t.op_Addition = function Color_op_Addition(v1, v2) {
        return new RayTracer.Color.ctor$1(v1.r + v2.r, v1.g + v2.g, v1.b + v2.b);
    };
    $t.op_Multiply = function Color_op_Multiply(v1, v2) {
        return new RayTracer.Color.ctor$1(v1.r * v2.r, v1.g * v2.g, v1.b * v2.b);
    };
    $p.ToByte = function Color_ToByte(value) {
        value = value > 1 ? 1 : value;
        return (System.Math.Floor$1(value * 255) | 0);
    };
    $p.ToString = function Color_ToString() {
        return String.Format("rgb({0},{1},{2})", $d.array(System.Object, [this.ToByte(this.r), this.ToByte(this.g),
            this.ToByte(this.b)]));
    };
});
RayTracer.Camera = $d.declare("RayTracer.Camera", System.Object, 0, $asm, function($t, $p) {
    $t.$ator = function() {
        this.forward = new RayTracer.Vector.ctor();
        this.right = new RayTracer.Vector.ctor();
        this.up = new RayTracer.Vector.ctor();
        this.pos = new RayTracer.Vector.ctor();
        this.lookAt = new RayTracer.Vector.ctor();
    };
    $t.ctor = function Camera(pos, lookAt) {
        $t.$baseType.ctor.call(this);
        this.pos = pos;
        this.lookAt = lookAt;
        var down = new RayTracer.Vector.ctor$1(0, -1, 0);
        this.forward = RayTracer.Vector.norm(RayTracer.Vector.op_Subtraction(lookAt, pos));
        this.right = RayTracer.Vector.op_Multiply(1.5, RayTracer.Vector.norm(RayTracer.Vector.cross(this.forward,
            down)));
        this.up = RayTracer.Vector.op_Multiply(1.5, RayTracer.Vector.norm(RayTracer.Vector.cross(this.forward,
            this.right)));
    };
    $t.ctor.prototype = $p;
});
RayTracer.Ray = $d.declare("RayTracer.Ray", System.Object, 0, $asm, function($t, $p) {
    $t.$ator = function() {
        this.start = new RayTracer.Vector.ctor();
        this.dir = new RayTracer.Vector.ctor();
    };
    $t.ctor = function Ray(start, dir) {
        $t.$baseType.ctor.call(this);
        this.start = start;
        this.dir = dir;
    };
    $t.ctor.prototype = $p;
});
RayTracer.Intersection = $d.declare("RayTracer.Intersection", System.Object, 0, $asm, function($t, $p) {
    $t.$ator = function() {
        this.thing = null;
        this.ray = null;
        this.dist = 0;
    };
    $t.ctor = function Intersection(thing, ray, dist) {
        $t.$baseType.ctor.call(this);
        this.thing = thing;
        this.ray = ray;
        this.dist = dist;
    };
    $t.ctor.prototype = $p;
});
RayTracer.Surface = $d.declare("RayTracer.Surface", System.Object, 0, $asm, function($t, $p) {
    $t.$ator = function() {
        this.diffuse = null;
        this.specular = null;
        this.reflect = null;
        this.roughness = 0;
    };
    $t.ctor = function Surface(diffuse, specular, reflect, roughness) {
        $t.$baseType.ctor.call(this);
        this.diffuse = diffuse;
        this.specular = specular;
        this.reflect = reflect;
        this.roughness = roughness;
    };
    $t.ctor.prototype = $p;
});
RayTracer.IThing = $d.declare("RayTracer.IThing", null, 66, $asm, function($t, $p) {});
RayTracer.Light = $d.declare("RayTracer.Light", System.Object, 0, $asm, function($t, $p) {
    $t.$ator = function() {
        this.pos = new RayTracer.Vector.ctor();
        this.color = new RayTracer.Color.ctor();
    };
    $t.ctor = function Light(pos, color) {
        $t.$baseType.ctor.call(this);
        this.pos = pos;
        this.color = color;
    };
    $t.ctor.prototype = $p;
});
RayTracer.Scene = $d.declare("RayTracer.Scene", System.Object, 0, $asm, function($t, $p) {
    $t.$ator = function() {
        this.things = null;
        this.lights = null;
        this.camera = null;
    };
    $t.ctor = function Scene(things, lights, camera) {
        $t.$baseType.ctor.call(this);
        this.things = things;
        this.lights = lights;
        this.camera = camera;
    };
    $t.ctor.prototype = $p;
});
RayTracer.Sphere = $d.declare("RayTracer.Sphere", System.Object, 0, $asm, function($t, $p) {
    $t.$intfs = [RayTracer.IThing];
    $t.$ator = function() {
        this.center = new RayTracer.Vector.ctor();
        this.radius2 = 0;
        this.surface = null;
    };
    $t.ctor = function Sphere(center, radius, surface) {
        $t.$baseType.ctor.call(this);
        this.center = center;
        this.surface = surface;
        this.radius2 = radius * radius;
    };
    $t.ctor.prototype = $p;
    $p.normal = function Sphere_normal(pos) {
        return RayTracer.Vector.norm(RayTracer.Vector.op_Subtraction(pos, this.center));
    };
    $p.RayTracer$IThing$get_surface = function Sphere_RayTracer$IThing$get_surface() {
        return this.surface;
    };
    $p.intersect = function Sphere_intersect(ray) {
        var eo = RayTracer.Vector.op_Subtraction(this.center, ray.start);
        var v = RayTracer.Vector.dot(eo, ray.dir);
        var dist = 0;
        if (v >= 0) {
            var disc = this.radius2 - (RayTracer.Vector.dot(eo, eo) - v * v);
            if (disc >= 0) {
                dist = v - System.Math.Sqrt(disc);
            }
        }

        if (dist == 0)
            return null;
        else
            return new RayTracer.Intersection.ctor(this, ray, dist);
    };
    $p.RayTracer$IThing$intersect = $p.intersect;
    $p.RayTracer$IThing$normal = $p.normal;
});
RayTracer.Plane = $d.declare("RayTracer.Plane", System.Object, 0, $asm, function($t, $p) {
    $t.$intfs = [RayTracer.IThing];
    $t.$ator = function() {
        this.norm = new RayTracer.Vector.ctor();
        this.surface = null;
        this.offset = 0;
    };
    $t.ctor = function Plane(norm, offset, surface) {
        $t.$baseType.ctor.call(this);
        this.norm = norm;
        this.offset = offset;
        this.surface = surface;
    };
    $t.ctor.prototype = $p;
    $p.intersect = function Plane_intersect(ray) {
        var result = null;

        var denom = RayTracer.Vector.dot(this.norm, ray.dir);
        if (denom <= 0) {
            var dist = (RayTracer.Vector.dot(this.norm, ray.start) + this.offset) / (-denom);
            result = new RayTracer.Intersection.ctor(this, ray, dist);
        }

        return result;
    };
    $p.normal = function Plane_normal(pos) {
        return this.norm;
    };
    $p.RayTracer$IThing$get_surface = function Plane_RayTracer$IThing$get_surface() {
        return this.surface;
    };
    $p.RayTracer$IThing$intersect = $p.intersect;
    $p.RayTracer$IThing$normal = $p.normal;
});
RayTracer.Surfaces = $d.declare("RayTracer.Surfaces", System.Object, 0, $asm, function($t, $p) {
    $t.cctor = function() {
        $t.shiny = new RayTracer.Surface.ctor($d.delegate(function(pos) {
            return RayTracer.Color().white;
        }, this), $d.delegate(function(pos) {
            return RayTracer.Color().grey;
        }, this), $d.delegate(function(pos) {
            return 0.7;
        }, this), 250);
        $t.checkerboard = new RayTracer.Surface.ctor($d.delegate(function(pos) {
            return ((System.Math.Floor$1(pos.z) + System.Math.Floor$1(pos.x)) % 2 != 0) ? RayTracer.Color().white : RayTracer.Color().black;
        }, this), $d.delegate(function(pos) {
            return RayTracer.Color().white;
        }, this), $d.delegate(function(pos) {
            return ((System.Math.Floor$1(pos.z) + System.Math.Floor$1(pos.x)) % 2 != 0) ? 0.1 : 0.7;
        }, this), 150);
    };
});
RayTracer.RayTracer = $d.declare("RayTracer.RayTracer", System.Object, 0, $asm, function($t, $p) {
    $t.cctor = function() {
        $t.maxDepth = 5;
    };
    $t.intersections = function RayTracer_intersections(ray, scene) {
        var closest = Infinity /* Double.PositiveInfinity */;
        var closestInter = null;
        for (var $i = 0, $a = scene.things, $length = $a.length; $i != $length; $i++) {
            var thing = $a[$i];
            var inter = thing.RayTracer$IThing$intersect(ray);
            if (inter != null && inter.dist < closest) {
                closestInter = inter;
                closest = inter.dist;
            }
        }

        return closestInter;
    };
    $t.testRay = function RayTracer_testRay(ray, scene) {
        var isect = RayTracer.RayTracer.intersections(ray, scene);

        return (isect != null) ? isect.dist : NaN /* Double.NaN */;
    };
    $t.traceRay = function RayTracer_traceRay(ray, scene, depth) {
        var isect = RayTracer.RayTracer.intersections(ray, scene);

        return isect == null ? RayTracer.Color().background : RayTracer.RayTracer.shade(isect, scene,
            depth);
    };
    $t.shade = function RayTracer_shade(isect, scene, depth) {
        var d = isect.ray.dir;
        var pos = RayTracer.Vector.op_Addition(RayTracer.Vector.op_Multiply(isect.dist, d), isect.ray.start);
        var normal = isect.thing.RayTracer$IThing$normal(pos);
        var reflectDir = RayTracer.Vector.op_Subtraction(d, (RayTracer.Vector.op_Multiply(2 * RayTracer.Vector.dot(normal,
            d), normal)));

        var naturalColor = RayTracer.Color.op_Addition(RayTracer.Color().background, RayTracer.RayTracer.getNaturalColor(isect.thing,
            pos, normal, reflectDir, scene));
        var reflectedColor = (depth >= 5 /* RayTracer.maxDepth */) ? RayTracer.Color().grey : RayTracer.RayTracer.getReflectionColor(isect.thing,
            pos, normal, reflectDir, scene, depth);
        return RayTracer.Color.op_Addition(naturalColor, reflectedColor);
    };
    $t.getReflectionColor = function RayTracer_getReflectionColor(thing, pos, normal, rd, scene, depth) {
        return RayTracer.Color.op_Multiply$1(thing.RayTracer$IThing$get_surface().reflect(pos), RayTracer.RayTracer.traceRay(new RayTracer.Ray.ctor(pos,
            rd), scene, depth + 1));
    };
    $t.getNaturalColor = function RayTracer_getNaturalColor(thing, pos, norm, rd, scene) {
        var result = RayTracer.Color().defaultColor;
        for (var $i = 0, $a = scene.lights, $length = $a.length; $i != $length; $i++) {
            var light = $a[$i];
            var ldis = RayTracer.Vector.op_Subtraction(light.pos, pos);
            var livec = RayTracer.Vector.norm(ldis);
            var neatIsect = RayTracer.RayTracer.testRay(new RayTracer.Ray.ctor(pos, livec), scene);
            var isInShadow = !System.Double.IsNaN(neatIsect) && (neatIsect <= RayTracer.Vector.mag(ldis));

            if (isInShadow)
                continue;

            var illum = RayTracer.Vector.dot(livec, norm);
            var lcolor = (illum > 0) ? RayTracer.Color.op_Multiply$1(illum, light.color) : RayTracer.Color().defaultColor;
            var specular = RayTracer.Vector.dot(livec, RayTracer.Vector.norm(rd));
            var scolor = (specular > 0) ? RayTracer.Color.op_Multiply$1(System.Math.Pow(specular, thing.RayTracer$IThing$get_surface().roughness),
                light.color) : RayTracer.Color().defaultColor;

            result = RayTracer.Color.op_Addition(RayTracer.Color.op_Addition(result, RayTracer.Color.op_Multiply(thing.RayTracer$IThing$get_surface().diffuse(pos),
                lcolor)), RayTracer.Color.op_Multiply(thing.RayTracer$IThing$get_surface().specular(pos),
                scolor));
        }

        return result;
    };
    $t.render = function RayTracer_render(scene, ctx, screenWidth, screenHeight) {
        var camera = scene.camera;

        for (var y = 0; y < screenHeight; y++) {
            for (var x = 0; x < screenWidth; x++) {
                var recenterX = (x - (screenWidth / 2)) / 2 / screenWidth;
                var recenterY = -(y - (screenHeight / 2)) / 2 / screenHeight;
                var dir = RayTracer.Vector.norm(RayTracer.Vector.op_Addition(RayTracer.Vector.op_Addition(camera.forward,
                    (RayTracer.Vector.op_Multiply(recenterX, camera.right))), (RayTracer.Vector.op_Multiply(recenterY,
                    camera.up))));

                var color = RayTracer.RayTracer.traceRay(new RayTracer.Ray.ctor(camera.pos, dir), scene,
                    0);

                ctx.fillStyle = color.ToString();
                ctx.fillRect(x, y, x + 1, y + 1);
            }
        }
    };
});
RayTracer.Program = $d.declare("RayTracer.Program", System.Object, 0, $asm, function($t, $p) {
    $t.Run = function Program_Run() {
        var defaultScene = new RayTracer.Scene.ctor($d.array(RayTracer.IThing, [new RayTracer.Plane.ctor(new RayTracer.Vector.ctor$1(0,
            1, 0), 0, RayTracer.Surfaces().checkerboard), new RayTracer.Sphere.ctor(new RayTracer.Vector.ctor$1(0,
            1, -0.25), 1, RayTracer.Surfaces().shiny), new RayTracer.Sphere.ctor(new RayTracer.Vector.ctor$1(-1,
            0.5, 1.5), 0.5, RayTracer.Surfaces().shiny)]), $d.array(RayTracer.Light, [new RayTracer.Light.ctor(new RayTracer.Vector.ctor$1(-2,
            2.5, 0), new RayTracer.Color.ctor$1(0.49, 0.07, 0.07)), new RayTracer.Light.ctor(new RayTracer.Vector.ctor$1(1.5,
            2.5, 1.5), new RayTracer.Color.ctor$1(0.07, 0.07, 0.49)), new RayTracer.Light.ctor(new RayTracer.Vector.ctor$1(1.5,
            2.5, -1.5), new RayTracer.Color.ctor$1(0.07, 0.49, 0.071)), new RayTracer.Light.ctor(new RayTracer.Vector.ctor$1(0,
            3.5, 0), new RayTracer.Color.ctor$1(0.21, 0.21, 0.35))]), new RayTracer.Camera.ctor(new RayTracer.Vector.ctor$1(3,
            2, 4), new RayTracer.Vector.ctor$1(-1, 0.5, 0)));

        var canvas = document.createElement("canvas");
        canvas.width = 256;
        canvas.height = 256;
        document.body.appendChild(canvas);
        var ctx = canvas.getContext("2d");
        var ticks = System.Environment().get_TickCount();

        RayTracer.RayTracer.render(defaultScene, ctx, 256, 256);

        ticks = System.Environment().get_TickCount() - ticks;
        System.Console.WriteLine$10("render time: " + $d.toString(ticks) + " ms");
    };
});

Choose sample:

Hello DuoCode WebGL Ray Tracer

Try it live in your browser!

Contact Us

We’d love to hear from you

DuoCode | take your C# code and skills to the web

C#-to-JavaScript compilerwith TypeScript supportpowered by Microsoft® Roslyn

Supports

Features

The power ofVisual Studio

The power ofthe C# language

The power of.NET Framework

The power ofDuoCode

Also featured in...

Compile C# code to JavaScript in Visual Studio

Features supported in DuoCode

C# language features

C# 6.0

More features

Visual Studio integration

Amazing C# debugging

DuoCode

Magic

C#

JavaScript

C#

JavaScript

C#

JavaScript

Choose sample:

Contact Us

C#-to-JavaScript compiler
with TypeScript support
powered by Microsoft® Roslyn

The power of
Visual Studio

The power of
the C# language

The power of
.NET Framework

The power of
DuoCode