LEGEND ✅ Full Support: Transpiles to equivalent JavaScript behavior. ⚠️ Partial Support: Works with caveats or minor differences. ❌ Not Supported: fundamentally incompatible logic (e.g., blocking I/O, unsafe pointers).

🏗️ Core Language Features

Feature

Status

Notes

Classes & Structs

✅

Transpiled to ES6 Classes. A plain class has a module of its own whatever it declares, an empty one over an interface's defaults or a base included, and every module that names it imports it; a class whose chain of bases reaches an attribute or a [ServerOnly] type has none, three levels down as much as one (class Underline : Mark over class Mark : Attribute), a base from a referenced library included. An exception class of the app's is a class, with a module of its own (see try / catch / finally). The chain is read by what each base derives from and never by its name, so a class over an interface named like an attribute keeps its module, and a name is a module wherever any declaration of it is one. A class, a static class, a record or a struct declared inside another type is a module of its own too, named by the types that contain it and its own name joined by $ (Cart$Item, A$B$C), which no top-level type can take: every reference to it, inside its owner or out, names that twin, so a nested class beside a top-level class of its name is never taken for it, and one inside a server-only class or an attribute has none, as its owner has none: client code that names it is refused (EQ2010), and a page declared in it has no route, while one inside an exception class crosses as that class does (Since 0.2.0-preview.61). A record and a struct have a twin whatever they declare, unless marked [ServerOnly], a record over a server-only record included (Since 0.2.0-preview.61).

Interfaces

✅

Used for TypeScript type checking (erased at runtime). A default member (a property, an indexer or a method with a body; an indexer since 0.2.0-preview.61) reaches the twin of every class that takes it without declaring it: converted from the interface's source, or, for the SDK's own interfaces an app implements (a theme, a code language), delegated to the runtime's copy. An interface from any other compiled assembly has neither, and the build refuses the class (EQ1008) (Since 0.2.0-preview.59). A call through an interface member that a [ServerOnly] method of a type that crosses implements is refused where its receiver can be that type (EQ2010), as is one through a base's method such a method overrides: the twin leaves the method out.

Enums

✅

Cross as their camelCase name (MainAlign.Start → 'start'), and a [Flags] enum as its number. .ToString(), interpolation and concatenation give the C# member name ("Start"), the same text the server prints, a flags combination's set flags ("Read, Write"), a value no member names as its digits, and nothing for a null nullable enum. ToString("D"), "X", "F" and "G", an interpolation's format and its alignment write what .NET writes, Enum.Parse, TryParse, GetName, GetNames, GetValues and IsDefined answer as .NET's, and a dictionary keyed by an enum crosses both ways, a name no member has being refused. Since 0.2.0-preview.15; the formats, the flags text, the statics of Enum and enum keys since 0.2.0-preview.60. An enum's Equals, a call or a method group, a Nullable enum's included, answers as .NET's, true only for the same enum type and value, and its GetHashCode hashes its underlying value as that value's own type does, a long enum's by the long's two halves; a member that aliases another (Gray = Grey) is the member .NET's Enum.GetName names, the first of that value, in ==, a switch, a pattern, its text, a key and ToDictionary, where it was a value of its own (since 0.2.0-preview.64).

Generics

✅

Fully supported (erased at runtime).

Extension Methods

✅

Resolved via Semantic Model and transpiled to direct calls.

Async / Await

✅

Maps to async / await and Promise.

Lambda Expressions

✅

Maps to Arrow Functions () => {}.

Pattern Matching

✅

is patterns, Property Patterns, Recursive Patterns. A type with nothing bound (o is int or long, int => …, case int:) tests the type, a long as a BigInt, an integer as a whole number and a char as a string of one code unit. A constant in a pattern, x is Limits.Max included, is tested by its value: a null matches any absence, a decimal and a NaN compare by value, and a long constant is a BigInt, as every long is (Since 0.2.0-preview.60). A positional pattern over a type whose Deconstruct the app wrote, an extension's included, calls it once for each value a test deconstructs, across the arms of a switch and the alternatives of an or too, as .NET does, and reads the parts it hands back, as a deconstruction does: it read the members the outs are named after, which a part the Deconstruct computes is not (Since 0.2.0-preview.61).

String Interpolation

✅

Maps to Template Literals ${var} . A format with quoted text ({date:dd 'de' MMMM}) keeps its quotes, and a raw interpolated string keeps its braces ($$$"""{{x}}""" is {{x}}) (Since 0.2.0-preview.60). An alignment is the number it is, a constant by its name or an expression of constants included ({name,Widths.Name}, {name,-(Widths.Name + 1)}), in a StringBuilder too (Since 0.2.0-preview.62). FormattableString.Invariant($"…") and string.Create(CultureInfo.InvariantCulture, $"…") write every hole in the invariant culture, and FormattableString.CurrentCulture($"…") and string.Create with the current culture or a null provider in the page's, a format and an alignment included; another culture fails the build (EQ2108), and an interpolation made a FormattableString anywhere else fails it with EQ2004, since the browser holds the text, not the format and its arguments (Since 0.2.0-preview.64). A FormattableString evaluates every hole before it writes any, as it holds its arguments, where string.Create writes each as it goes, and a hole held as an object writes the number or the date it holds in the culture the call names (Since 0.2.0-preview.64).

String & char literals

✅

A string or a char keeps the value C# reads, whatever spells it: a lone surrogate ("x\uD83D"), a control character, and the escapes only C# has ('\a', '\e', '\x041', '\U00000041'). A UTF-8 literal ("ab"u8) has no twin and fails the build (EQ1004) (Since 0.2.0-preview.60).

Null-Coalescing

✅

?? and ??= mapped to JS equivalents.

Object Initializers

✅

new Obj { Prop = 1 } over a record, a struct, a plain class, an exception or a vocabulary type whose twin the runtime transpiles (the spreadsheet's engine and the forms' models, CellRef, FieldError, SheetController…), applied once the constructor has returned, as C# applies it (a plain class took it as a trailing config object, an exception dropped it, and a transpiled vocabulary type handed it to a slot its twin does not have, before 0.2.0-preview.61; a component takes it as its props): every initializer of the type has run, the member's own included, and the values are read after them. A nested collection initializer (Items = { 1, 2 }) adds to the collection the member holds, through the Add the bound tree binds (an extension method's through its home, and a list's, a set's or an ICollection<T> member's as a call to it is); a nested object initializer (Inner = { N = 3 }) assigns into the object the member holds; and an entry ([key] = value) is written through the type's indexer. A dictionary's pair (Map = { { "a", 1 } }) is its Add, which refuses a key already there. Every part is evaluated in the method it was written in, so an await in an element works, and each element is applied before the next one's parts are evaluated, the member it adds to or assigns into read before its own parts, as C# applies it. An element with no lowering fails the build (EQ1004) (Since 0.2.0-preview.61).

field (C# 14)

✅

Guarded properties: the twin gets a $name slot (a name no C# field can take), a getter and the accessor's own body. A static one keeps its slot on the type, a record's included, and the slot starts as the property's initializer or its type's default (Since 0.2.0-preview.60). A record's and a struct's instance one runs its accessors' bodies over the slot, as a class's does, and one whose getter has a body is state its record compares and copies; it was held under the property's name, with its setter's body dropped, before 0.2.0-preview.61 (Since 0.2.0-preview.61).

Virtual and override properties

✅

A property a derived type can override or that overrides one (an auto-property declared virtual or override) keeps its value in a store of its own ($name) under accessors on the twin's prototype, in a class, a record and a struct alike, so every read reaches the override and no initializer reaches the accessor of another level: an auto-property over a computed one, or a computed one over an auto-property, threw at new or answered the base's value before 0.2.0-preview.61. An override that declares only the getter of a property whose base has both keeps the base's setter, as C# inherits it. A record compares, hashes and copies the store, as .NET compares a backing field. A twin with a store writes it in JSON under its property's name, so a server action receives the property by its C# name. One difference stays: in a type that overrides an auto-property with another, base.Name reads the override's value, where .NET reads the base's own field, since the two share one store (Since 0.2.0-preview.61).

Members that hide (new)

✅

A method that hides an inherited member, with new or with the same signature and no override, is reached as C# reaches it: through the base type the base's method answers, and through the hiding type the hiding one, a call, a method group, a base call and ?. alike, a generic method over its own type parameter included, and so does a member the runtime reads by its .NET name, so ((object)c).GetHashCode() is object's over a public new int GetHashCode(). Its twin holds it under a name of its own (name$1), and an override of a new virtual method fills that method's place. So does a method beside an explicit interface implementation of its name, so a call through the class reaches it and one through the interface the explicit one. One that hides a member, or stands beside such an implementation, and answers an interface fails the build (EQ1007), and a property or a field that hides one still shares its name with it (#563, since 0.2.0-preview.61).

init accessors

✅

Emitted as a JS setter, because an init body is where a type states its invariant, and dropping it would lose the check on the client.

Collection Initializers

✅

new List<int> { 1, 2 } maps to [1, 2]. A list built with an argument and an initializer holds both, as C# builds it: a copy of the source, never the source itself, or nothing for a capacity, then each element in order, the source or the capacity read first. A capacity is still evaluated, and a negative one is refused as the constructor refuses it. So new List<int>(source) { 3 } is [...source, 3] and new List<int>(10) { 1, 2 } is [1, 2], written out or target-typed, and List<int> c = new(source) is a copy. A capacity dropped the elements, and a source was joined to them with a comma, before 0.2.0-preview.61 (Since 0.2.0-preview.61).

IEnumerable<T> of your own

✅

A class, a record or a struct that implements IEnumerable<T>, or only IEnumerable, is enumerated as its own GetEnumerator() says, by foreach, a spread, string.Join and every LINQ operator, each through the one C# binds for it: a foreach over the class walks its own public GetEnumerator() (a struct enumerator's included), and LINQ, a spread, string.Join and a foreach over the interface walk the IEnumerable<T> one, explicit or not, so the two may walk different sequences, as in .NET. It is the sequence an iterator method yields, or an enumerator of your own, a class that is its own enumerator included, walked by its MoveNext and Current and disposed when the walk ends, a break included. A derived class's override answers, the explicit IEnumerable.GetEnumerator() beside the generic one is the same sequence, and so is an explicit Current beside a public one. A class with only a public GetEnumerator() is walked by foreach too. The twin has one iteration and one Current, so a type that implements IEnumerable<T>, or IEnumerator<T>, over two types fails the build (EQ1007), and so does an explicit IEnumerable.GetEnumerator() or Current that answers otherwise than the member the twin keeps, where one that hands back its answer (=> GetEnumerator();, => Current;) is held as one. A .NET collection's own GetEnumerator() (=> items.GetEnumerator()) has no translation and fails the build (EQ2004): yield the items instead (#612, since 0.2.0-preview.61).

Deconstruction

✅

var (a, b) = tuple maps to [a, b] = tuple, and so do (var c, var d) = … and nested designations. A record or a struct deconstructs through the Deconstruct it calls, in every shape: a declaration, an assignment ((a, b) = point, (var a, b) = point), a foreach (var (a, b) in points) and a nested deconstruction. A record's own reads its members, and a Deconstruct the app wrote runs. The targets' receivers and indices are evaluated before the value, as C# evaluates them, so (xs[i++], xs[i++]) = point writes the elements C# writes (Since 0.2.0-preview.60). Each part reaches its target as C# puts it there: converted to the target's type (an int part into a long), and written by what the target is, a dictionary's entry through its class, in an assignment, a declaration and a loop (Since 0.2.0-preview.60).

Expression variables

✅

What a pattern, an out var or a deconstruction declares is declared where C# declares it, in every kind of member: in the enclosing block after an if or an expression statement, inside a loop or a using, and fresh on every loop iteration and every call, so a closure keeps its own value. A name JavaScript reserves (@class) is renamed once, at its declaration and every reference (Since 0.2.0-preview.59).

Local Functions

✅

Transpiled to inner functions. An out or ref parameter carries its value back to the caller, as a method's does (Since 0.2.0-preview.60).

for loops

✅

1:1. A loop's variable is one per loop, as in C#: a closure made in the body reads its current value, never a copy of its own iteration's, and so is what its initializer declares (out var n, var (i, j) = (0, 3)), a head of expressions included (for (Seed(out var n); …)) (Since 0.2.0-preview.60).

Delegates

✅

Called as values, by name, through a member, or from any expression (handlers[0](x), Make()(x), since 0.2.0-preview.60). A method group of a member no twin carries, a .NET type's or a package's, is the delegate its call is, translated as the call is: items.Select(DateTime.Parse) reads each text in the page's culture and never hands Select's index to the parse, Func<double, double> round = Math.Round rounds a half to even, the receiver is read once and a null one refused where the delegate is made, as .NET refuses it, and a group whose call has no translation fails the build with the call's own refusal (EQ2004). A delegate built with new from a method group or a lambda is that function, and built from another delegate, new Func<int, int>(f), a new function that calls f, as .NET's new delegate over its Invoke: never f itself, f read once where it is made, and a null one refused there (Since 0.2.0-preview.64). One whose parameters hand a value back through an out or a ref, built from another delegate, fails the build (EQ2004) (Since 0.2.0-preview.64).

Records (with)

✅

A copy of the record onto its own class, then the members the expression names: like .NET's copy, it runs no initializer and no constructor. A struct's with, and one on the code engine's records, go through the twin's own copy. A record whose chain declares a copy constructor is copied through it, as C#'s with is: a declared one starts its members at their zero, runs its base's copy with what : base(…) passes and then its body, and a synthesized level copies its own members (Since 0.2.0-preview.61).

Constructors

✅

A record's, a struct's or a plain class's twin constructor is the C# constructor the call binds, each one reached by the counts of arguments it takes, its optional parameters counted (a plain class kept its widest one before 0.2.0-preview.61). One that does its own work (the primary one, or an explicit one that does not chain) binds its parameters, runs every initializer in declaration order, a field's and a property's alike, a derived type's before its base's constructor, calls its base's constructor with its own arguments and runs its body; one that chains with : this(…) runs the one it chains to and then its own body, even when that one's body returns early. Each argument lands in its parameter's place and is evaluated in the order it is written, in new, : this(…), : base(…) and a base clause alike: a named one, an omitted optional one, and a params array passed whole (named or not) or packed from its elements; a variable an argument declares (out var n) is declared where it is evaluated, and a constructor's parameter is a variable its body may assign. A record's copy constructor is no branch. Two constructors that take the same count of arguments fail the build (EQ1009), and so do a chain to a constructor that chains in turn and : this() to a struct's implicit constructor beside constructors of its own. A struct's zero (default, an array's slot, new S() with no constructor of its own, a generic struct's, which holds each type argument's zero, and one from another assembly included) runs none of it, its static constructor included. A plain class's primary constructor binds its parameters as a record's does, and one a member reads is held on each instance under its name, so one that lands on another member's name fails the build (EQ1007). One difference stays: a base constructor that reads a derived class's member through a virtual member reads it unset, where .NET reads it initialized, since JavaScript lets nothing touch the instance before super() returns (Since 0.2.0-preview.61).

Indexers

✅

An instance indexer is its twin's item(…) and setItem(…, value), and every access to it calls them: a read, a write, a compound assignment, ++ on a value of any type, ??=, ?[…], a deconstruction's target, a key from the end (^1, at the count its type names) and an object initializer's entry, the receiver and the keys evaluated once each, each key in its parameter's place (a named key, an omitted optional key, a params key). An assignment answers the value it assigned, whatever the setter does with its copy, and an explicit implementation of an interface's indexer answers the interface's accesses. A second indexer in a type, or any member on Item or SetItem beside one, fails the build (EQ1007) (Since 0.2.0-preview.61). An access through a list's face (IList<T>, IReadOnlyList<T>, IList) reaches whatever the face holds when it runs, an array's or a list's element and a twin's item and setItem alike, in every one of those forms, and its Count counts a type of your own by its own Count, never by a Length beside it: the face read a subscript and a length, which a twin does not answer, before 0.2.0-preview.61 (Since 0.2.0-preview.61).

Ranges

✅

x[a..b] over a string, an array or a list is JavaScript's slice, and an endpoint that may be ^0 resolves against the length as Index.GetOffset does. Over a type of your own with a Length (or a Count) and a Slice(int start, int length), it calls that Slice as C# lowers the range: the receiver once, then the endpoints in the order they are written, then the count, read only where an endpoint counts from the end or the end is left open. So strip[1..3] is Slice(1, 2), where it called the twin's slice(1, 3) before 0.2.0-preview.61. A range handed to an indexer that takes the Range itself fails the build (EQ2004), as a Range stored as a value does (Since 0.2.0-preview.61).

Static initialization

✅

A type's statics start at their zero, then the initializers run in declaration order, then the static constructor, once, the first time one of them is read or written: static int A = B + 1; static int B = 2; makes A 1, as in .NET, in a record, a struct, a class, a static class and a component. A type with a static constructor runs it before its first instance and the first use of any of its static members, a method, a computed property and an operator included. The initializers run in declaration order across fields, properties and field-like events, and the static constructor's body after them, a return in it ending it alone; one that throws makes every use of the type throw a TypeInitializationException, as .NET does; a static whose initializer C# folds to a constant is its value; and a component's static constructor runs once (Since 0.2.0-preview.61).

typeof

✅

Maps to type name string literal.

Base types

✅

A class extends its base's twin however the base is written: bare, with its namespace, through an alias or with global:: (Since 0.2.0-preview.60).

Qualified type names

✅

A type reached through its namespace, part of it, the whole of it or global:: is imported as a type reached through a using is: inside App.Chat, Portal.Fold.Text(n) answers what Fold.Text(n) answers under using App.Portal; (Since 0.2.0-preview.61).

base calls

✅

Maps to super keyword.

using static

✅

A member reached by its simple name answers what its qualified spelling answers: PI is Math.PI, Join(…) is string.Join(…), an enum's High is Level.High, and Now under using static System.DateTime is DateTime.Now (Since 0.2.0-preview.61; until then a .NET member outside Math, MathF, string, a constant and an enum failed the build even where its qualified spelling translated). A .NET member whose qualified spelling has no translation either fails the build (EQ2004) instead of reaching the browser (Since 0.2.0-preview.60).

A type's own Count

✅

A type the app or a library it references declares reads its own Count: a library's domain model read it as an array's length, undefined (Since 0.2.0-preview.60).

cast & as

✅

Maps to JS passthrough/truncation.

sizeof

✅

Maps to C# primitive sizes.

Anonymous Methods

✅

delegate(...) { ... } maps to arrow functions.

params

✅

A REST parameter (...xs). Both C# call forms work: expanded arguments and an array passed whole, which spreads. Since 0.2.0-preview.15.

stackalloc

✅

Maps to Typed Arrays (e.g., Int32Array).

yield return

✅

Maps to JS Generator Functions (function*).

try / catch / finally

✅

The catch clauses are ONE JavaScript catch that tries them in C#'s order: each by its exception type, a type derived from it included, and by its when filter, which declares its own variables (out var n, a pattern) and answers false where it throws, as .NET's does. An exception no clause takes goes on, and throw; rethrows the exception caught. An exception is a JavaScript Error that carries its .NET types, an exception class of the app's own and Exception e = new("…") included, so e is ArgumentException, a switch over exceptions and as test the type too, and an exception the runtime throws is the type .NET throws there (an overflow, a missing key, a bad format, a refused cast); a JavaScript TypeError is a NullReferenceException. One difference stays, the platform's: .NET runs a filter BEFORE the finally blocks between the throw and the clause, and JavaScript after them. Since 0.2.0-preview.60. A framework exception's message is composed as .NET composes it: where no message or a null one was given, the text .NET writes for that constructor, read from .NET itself, then (Parameter 'x'), and the actual value and a disposed object's name on lines of their own, an aggregate's inner messages after its own and a type initializer's sentence, and ParamName, ActualValue, InnerException and TypeName read what the constructor took, an aggregate's InnerException being its first inner one, the runtime's own argument exceptions naming their parameter too (Since 0.2.0-preview.61). A null argument is refused as .NET refuses it, an ArgumentNullException naming the parameter, by LINQ's Max, Min and ToDictionary, by a LINQ operator handed a sequence that is not a list (Concat's second, Zip's first), by new Guid(text), char.GetUnicodeCategory(text, i), CancellationToken.Register and CreateLinkedTokenSource, and CompareTo(object) answers 1 for a null, as .NET's does. A member lowered to JavaScript's own method, LINQ over a list among them, still reads a null through null, a NullReferenceException: the conformance suite calls every member of the translated surface with a null for each reference parameter, and lists those in null-argument-gaps.baseline.txt with their reasons (Since 0.2.0-preview.61). An exception class of the app's is a class over the runtime's exception base, the Error that carries its types: its fields, its properties, its constructors and its methods are its own, and its base call hands what a new of its .NET base hands, so : base(message, inner) reaches Message and InnerException, : base("bad", name) over ArgumentException reads bad (Parameter 'x') and its ParamName, a class over InvalidOperationException that gives no message reads that type's own text, a missing message over Exception is .NET's default (Exception of type 'App.Failure' was thrown.), a member of its own under a name the base holds (a Name, an override of Message or of ParamName) answers for it, and a generic one is caught by its construction (catch (Failed<int>)) from the moment its constructor runs, a throw this there included. A missing message names the type as .NET names it at run time (App.Failed1[System.Int32], App.Outer+Inner). It is transpiled as any class is: one the browser never sees, whose members reach what it cannot run, is marked [ServerOnly], and two of its constructors that take as many arguments are refused (EQ1009), save the one only .NET's serialization calls, (SerializationInfo, StreamingContext), which Visual Studio's template writes and the twin leaves out, and a call of that one the browser would make, a new or the base call of another constructor, fails the build (EQ1009). An exception built or tested where a type argument it carries is a type parameter fails the build too (EQ2014), since JavaScript erases it: new Failed<T>() in a generic method, catch (Failed<T>), new Missing() inside the generic class that declares it. One declared inside another type is a class too, its twin named by its owner (Holder$Nested), and so is what an exception class declares, a record of the reason it carries (Rejected$Reason). In a snippet compiled on its own, with no project to read its bases from, an exception class of the app's is still the runtime's Error` with its types and none of its members (#611, since 0.2.0-preview.61).

throw expressions

✅

x ?? throw …, c ? a : throw … and => throw …, the exception evaluated only where it is thrown, an await in it included. Since 0.2.0-preview.60.

lock

⚠️

Transpiled to the body alone (JS is single-threaded). Its expression runs once, in front of it, unless it only reads a variable, a field or this (Since 0.2.0-preview.60; one that declares a variable, since 0.2.0-preview.59). new object(), the usual gate, is a fresh object, with or without an empty initializer.

🔄 LINQ Support

The compiler includes specialized strategies for nearly all LINQ methods.

Logic

Methods

Status

Filtering

Where, OfType

✅

Projection

Select, SelectMany, Cast

✅

Partitioning

Skip, Take, SkipWhile, TakeWhile

✅

Ordering

OrderBy, OrderByDescending, ThenBy, Reverse

✅

Aggregation

Count, Sum, Min, Max, Average, Aggregate

✅

Quantifiers

Any, All, Contains

✅

Sets

Distinct, DistinctBy, Union, Intersect, Except, Concat

✅

Elements

First, FirstOrDefault, Single, Last, ElementAt

✅

Utility

SequenceEqual, DefaultIfEmpty

✅

Generation

Enumerable.Range, Enumerable.Repeat, Enumerable.Empty

✅

Conversion

ToList, ToArray, ToDictionary, ToHashSet

✅

Grouping/Join

GroupBy, Join, Zip

✅

Every operator reads its source as the sequence .NET enumerates, whatever the browser holds it as: an array or a list as it is, a HashSet, a dictionary's pairs and the runtime's sorted set, sorted dictionary, sorted list, queue, stack and linked list by their own enumeration (a stack from its top), and a string by its chars, the UTF-16 code units. ToList and ToArray always make a new array, so a copy and its source are two lists. A string's foreach and ToCharArray give code units too, a surrogate pair being two chars, new string(chars) and new string(chars, start, length) build their text, and a char static handed over as a delegate works, "a1b2".Count(char.IsDigit) and Count(IsDigit) under using static System.Char alike (Since 0.2.0-preview.60).

An operator that holds a key or an element finds it as EqualityComparer<T>.Default does, the one decision a dictionary, a set and Contains read: a record, a struct, a decimal and a date by value, an anonymous object and a tuple by their members, an array they hold by reference, and a class by its own Equals where it or a subclass overrides one and by reference otherwise. That holds for Join and GroupJoin by their key, Distinct, Union, Intersect and Except by their element, DistinctBy, UnionBy, IntersectBy and ExceptBy by their key, and GroupBy, ToLookup and a lookup's indexer by their key, a NaN key equal to itself, and a null key matches nothing in Join and GroupJoin, as .NET skips it. An enum with aliases, two members of one value, keys as that one value, as .NET's does (Since 0.2.0-preview.64). A join by a composite key (new { x.K } or (x.K, 0)) matched nothing, Union, Intersect and Except kept every anonymous object, tuple, record, decimal and date, a class's own Equals was never asked, two records holding different arrays of the same items were one to Distinct, and GroupBy made each NaN a group of its own, before 0.2.0-preview.64 (Since 0.2.0-preview.64).

Enumerable.Range and Repeat evaluate their arguments once, where C# does, an await among them included: Range(Start(), 3) calls Start once, and Repeat(new List<int>(), 3) repeats one list. A negative count, or a Range past int.MaxValue, throws .NET's ArgumentOutOfRangeException (Since 0.2.0-preview.60).

A comparer handed to ToDictionary, ToLookup, GroupBy, Distinct, ToHashSet or SequenceEqual passes the fence a collection's constructor passes. One that asks for the key type's default equality (EqualityComparer<T>.Default, a null comparer, or StringComparer.Ordinal for a string) answers as the operator does without it, each selector in its parameter whether it is named or not, and any other, such as StringComparer.OrdinalIgnoreCase, fails the build with EQ2007. ToDictionary and GroupBy refused every comparer, ToLookup called one as an element selector and Distinct dropped whatever it was handed, before 0.2.0-preview.61 (Since 0.2.0-preview.61). SequenceEqual answered its first sequence when it was handed a comparer, before 0.2.0-preview.62 (Since 0.2.0-preview.62).

Each overload answers as its own .NET overload, each argument in the parameter it binds to, named or not. FirstOrDefault(defaultValue), LastOrDefault(defaultValue) and SingleOrDefault(defaultValue), with a predicate or without, answer the element when there is one, a null element included, and the value handed otherwise, and SingleOrDefault refuses a second element or a second match with .NET's InvalidOperationException. Zip(second) answers pairs and Zip(second, third) triples, read as First, Second and Third or deconstructed, as many as the shortest sequence holds. Average computes the mean in the element's type: an int or a long summed exactly in a long, an OverflowException past long.MaxValue, and divided as a double, a float mean rounded to a single, a decimal one as a decimal, a nullable over its values alone and null when it has none, and an empty sequence refused with an InvalidOperationException where the answer is not nullable. SequenceEqual compares by the element type's default equality: a long and a decimal by value, a record by its members, a class by its own Equals and by reference where it has none, an array by reference, and NaN equal to itself. Before 0.2.0-preview.62 a default value was called as a predicate, the third sequence of a Zip as a result selector, and a mean of longs threw a TypeError (Since 0.2.0-preview.62).

📦 .NET Types (BCL)

We map common .NET types to their JavaScript equivalents.

Primitives

.NET Type

JavaScript Equivalent

string

String

int, double, float

Number

bool

Boolean

object

Object

dynamic

any

System.String

•

✅ Join, Format. string.Join reads any sequence (an array, a list, a HashSet, a LinkedList, a dictionary's keys, a sequence behind an interface) and writes each value as .NET's ToString writes it: a bool as True, an enum by its member's name, a float by its own digits, a double in .NET's notation (1E+21), a null as nothing; values passed one by one are each written by their own type, and a null separator writes nothing (Since 0.2.0-preview.61)

•

✅ IsNullOrEmpty, IsNullOrWhiteSpace

•

✅ Split, Replace, Substring, Trim. Split answers as .NET's overload does: a set of separators (an array of chars or strings, or chars written one by one) splits at any of them, the first in the set's order winning at a place; a null or empty single separator splits nothing and a null or empty set splits at .NET's white space; the count caps the entries, the last one taking the rest; TrimEntries and RemoveEmptyEntries apply, written out or held in a variable; and a negative count or an undefined option throws .NET's exception (Since 0.2.0-preview.62)

•

✅ ToLower, ToUpper and their invariant pair change case as .NET 10 does: each code unit, or surrogate pair, becomes exactly one other (ß and ﬁ stay as they are, ᾳ upper-cases to ᾼ, and a capital sigma lowers to σ wherever it stands), and the two i's are the culture's: tr and az upper-case i to İ and lower-case I to ı, every other culture upper-cases ı to I and lower-cases İ to i, and the invariant culture leaves İ and ı as they are. A letter Unicode 16 or 17 cased, such as ƛ, whose capital came with Unicode 16, changes case as .NET 10 changes it over ICU 78, Ubuntu 26.04's, and over macOS 26's, in every browser, one whose own Unicode is older included; a server whose ICU is older, Ubuntu 24.04's or Windows' own, leaves it as it is, so a page rendered there and hydrated in a browser can case those letters two ways (Since 0.2.0-preview.66, where it kept its case as those servers do). A culture argument crosses as CultureInfo.CurrentCulture or a null, which are the page's culture, and CultureInfo.InvariantCulture; any other fails the build (EQ2108) (Since 0.2.0-preview.62, where the browser lengthened ß to SS, read a final sigma in its context, knew no culture and dropped the one the call named)

•

✅ StartsWith, EndsWith

•

✅ Equals, StartsWith, EndsWith, Contains, IndexOf, LastIndexOf and Replace given a StringComparison, by that comparison, and CompareTo by the current culture; a search by a culture comparison fails the build (EQ1004) (Since 0.2.0-preview.60)

System.DateTime, TimeSpan, DateOnly, TimeOnly & DateTimeOffset

The temporal types are backed by tick-precise compat types (100-ns ticks, proleptic Gregorian calendar, not the lossy new Date() / numeric-milliseconds mapping). Ctors, components, Add*, arithmetic (-→TimeSpan), comparisons, and .ToString() all match .NET, a date's text written through one formatter in the culture in force (Since 0.2.0-preview.61). A TimeSpan writes the format it is given, through ToString, a hole and a placeholder alike: c, t and T its constant form, g and G its general ones with the culture's decimal separator, a custom format such as hh\:mm token by token, and a format .NET refuses its FormatException in .NET's words (Since 0.2.0-preview.62, where every format wrote the constant form); values cross the SSR wire as ISO-8601 / "c" strings and are hydrated back into the compat type. TryParse(text, out var value) of each of the five answers true with the value its Parse reads, or false with the type's default in value for a text Parse refuses and for a null one, as .NET's does (Since 0.2.0-preview.62, where four of them failed the page and DateOnly's answered null). Parse and TryParse read in the culture the call names, as .NET does: with no provider, CultureInfo.CurrentCulture or a null one, the page's culture, and with CultureInfo.InvariantCulture, the invariant one. They read the numeric forms the culture writes: a date of three numbers in the order of its short date pattern (01/02/2024 is the 1st of February in pt-BR and the 2nd of January in en-US), its separators beside /, - and ., a clock with its own separator (fi-FI's 21.30, where three short numbers joined by points are a clock and 10.11.12 is 10:11:12) and its own AM and PM designators beside AM and PM, before or after the clock, the clock before or after the date, a fraction after the seconds with a point or a comma, a zone, and the ISO form (2024-01-15T09:30:00Z). A TimeSpan is read as .NET reads one with no format: by how many numbers it has and what stands between them, against the invariant pattern d.hh:mm:ss.fffffff and the culture's own, d:hh:mm:ss and its decimal separator, so 10 is ten days, 1:2 an hour and two minutes, 1:02:03:04 a day and two hours, and 24:00:00, which no clock reads, twenty-four days; a part past its bound or a span past the type's range throws .NET's OverflowException in its words, and a fraction past seven digits is rounded as .NET rounds it (Since 0.2.0-preview.62, where only [-][d.]hh:mm:ss[.f] was read and no part was checked, so 00:60:00 was an hour). So a value written with ToString() reads back, and what is refused is refused in .NET's words. Any other culture fails the build (EQ2108), and so do styles other than white space and a span (EQ1004); ParseExact, TryParseExact and GetDateTimeFormats are not translated (EQ2004). Convert.ToDateTime reads a text as DateTime.Parse does, a null one as MinValue, an object by what it holds and a date as itself, and a value of another type throws .NET's InvalidCastException; a char held in an object is read as a text of one character, since a boxed value does not carry its type (#552) (Since 0.2.0-preview.62, where every reader read the invariant shapes, a provider failed the page and Convert.ToDateTime answered the text). A month's name, a date of two numbers, a clock with no date and calendars other than the Gregorian one are not read yet (#807). A constructor that takes a Calendar fails the build (EQ1004), since the browser has none of .NET's calendars, DateOnly's included (Since 0.2.0-preview.62, where it dropped the calendar). Every member of the five answers as .NET's where its twin carries it, and fails the build naming it (EQ2004) where none does (Since 0.2.0-preview.64, where each went out under its camel-cased name and failed the page). A TimeSpan's Microseconds, Nanoseconds, TotalMicroseconds, TotalNanoseconds, Multiply, Divide, Subtract, Compare and Equals answer, and so do its *, / and sign, a product or a quotient rounded to the even tick and a NaN or an overflow refused in .NET's words; so do a date's Compare, Equals and UnixEpoch, a DateOnly's ToDateTime, a TimeOnly's Add, IsBetween and ToTimeSpan, and an instant's DayOfYear, TotalOffsetMinutes, ToUniversalTime(), EqualsExact, Compare, Equals and UnixEpoch. TryFormat, the interop forms (ToBinary, FromBinary, ToFileTime, FromFileTime, ToOADate, FromOADate), IsDaylightSavingTime and GetTypeCode fail the build. A method group of any of them is the delegate its call is, so items.Select(DateTime.Parse) reads each text as the call reads it (Since 0.2.0-preview.64, where it called the parse once, with no text). A named argument lands in its parameter's place, whatever order it is written in (Since 0.2.0-preview.64). See the .NET BCL Coverage & Conformance table below for the per-type detail.

System.Collections.Generic

•

✅ List<T> → Javascript Array []; Remove answers the bool .NET does and compares as EqualityComparer<T>.Default does, a record by value, a tuple element by element and NaN by NaN (Since 0.2.0-preview.59). IndexOf, LastIndexOf, Contains and Remove, Array.IndexOf and Array.LastIndexOf, and LINQ's Contains compare by that one comparison, chosen from the element type: a NaN, a record, a tuple and a decimal found by value, a class by its own Equals, a tuple's array member by reference, as ValueTuple.Equals compares it. Sort and Array.Sort are .NET's introspective sort, unstable as .NET's is, so equal elements land where .NET's land, by the type's default comparer (a double's NaNs first), a Comparison<T>, a StringComparer's six, Comparer<T>.Create or a comparer of your own, with .NET's exceptions; any other comparer fails the build (EQ2007). BinarySearch answers the complement of the insertion point for a miss, Find and FindLast the element type's default, RemoveAll how many it removed, CopyTo writes into the array it is handed, and the ranges of FindIndex, FindLastIndex, IndexOf and LastIndexOf are checked in .NET's words (Since 0.2.0-preview.61)

•

✅ ICollection<T>'s Add and Clear add and empty as the collection behind the interface does when the call runs: a list appends, a set adds a value it does not hold, a linked list adds last, a dictionary adds the pair and refuses a key already there in .NET's words, and a type of your own runs its own Add and Clear, a member's collection initializer (Items = { 1, 2 }) included. They were an array's push and splice, which a set, a linked list and a dictionary lack, before 0.2.0-preview.61 (Since 0.2.0-preview.61)

•

✅ Dictionary<TKey, TValue>, IDictionary and IReadOnlyDictionary → the runtime's dictionary class ($eq.collections.dictionary), which holds its entries by slot as .NET's does: it enumerates in insertion order, and an entry added after a removal takes the removed one's place, the last freed first, so d[3] = 30; d[1] = 10; enumerates 3,1. Each key keeps its type (an int key comes back a number, a long a BigInt, a char a char) and is found as the key type's default comparer finds it: by value for a record, a struct, a tuple, a decimal or a date, by identity for a number, a string, a char, a bool, an enum or a Guid, and by the value's own equality where the type does not decide (object, an interface, a type parameter, a class), so two equal records under object are one key; a tuple key's array element by reference (Since 0.2.0-preview.61). new Dictionary<K, V>(other) copies, a deconstructing foreach (var (k, v) in d) works on every dictionary, the sorted ones included, TryAdd, ContainsValue, Remove(key, out value), Keys.Contains and Keys.Count answer as .NET's, and ToDictionary builds the same class. Add, a collection initializer and the constructor that copies pairs refuse a key already there with .NET's ArgumentException, in each collection's words, while the indexer, an object initializer's [key] = value and TryAdd replace or decline, and new KeyValuePair<K, V>(key, value) and KeyValuePair.Create build the pair a dictionary yields (Since 0.2.0-preview.60). A key added while a foreach walks the dictionary ends the walk with an InvalidOperationException, as .NET's enumerator does, while an overwrite, a removal and Clear run on, and a sorted dictionary and a sorted list refuse every change, their keys' and values' walks too, in the words of System.Collections, where the two live, a sorted dictionary's Remove of a key it does not hold and its Add of one it holds counted as its tree counts them, and its Remove(key, out value) of a key it does not hold counted as nothing, as CollectionExtensions asks first (Since 0.2.0-preview.64, #864). A dictionary in server-rendered state, in a Server Action's result or arguments, or in a topic's payload crosses as its [key, value] pairs and arrives as the class, its keys in their type, in the order it enumerated, integer keys included: a JSON object would have listed those first and ascending (Since 0.2.0-preview.61, #437). A comparer that asks for what the browser already does (null, EqualityComparer<T>.Default, StringComparer.Ordinal) builds the dictionary, and a sorted one keeps the order it asks for (Since 0.2.0-preview.61), while one that changes equality, such as StringComparer.OrdinalIgnoreCase, fails the build with EQ2007. Since 0.2.0-preview.60. Its Keys and Values are live views, as .NET's are: one read after the dictionary changed shows the change, a key added while one is walked ends the walk, the keys' own Contains finds a key as the dictionary does, and each element comes back as it is, a delegate included. A sorted dictionary's and a sorted list's are too, where they were copies, and a change asked of a view, an Add or a Remove through ICollection<T>, whether or not the view holds the value, or a key written through a sorted list's Keys[i], throws the NotSupportedException .NET throws, in each collection's words; a sorted dictionary's TryAdd, which C# finds on CollectionExtensions, was a ReferenceError, and an extension method of your own named TryAdd or GetValueOrDefault is called as yours, where it was taken for the dictionary's (Since 0.2.0-preview.64, #864). A LINQ query over a view, as over any source, reads it whole before its first callback (#685). EnsureCapacity answers the prime .NET settles on, a capacity constructor and a copy size the dictionary as .NET's do, and TrimExcess packs the entries so the next key goes after the others (Since 0.2.0-preview.61).

•

✅ HashSet<T>, ISet<T> and IReadOnlySet<T> → the runtime's set ($eq.collections.hashSet), built wherever one is made (a constructor, an initializer, a collection expression, ToHashSet, a value that crossed from the server). It holds its elements by slot in the table the runtime's dictionary keeps its keys in: an element added after a removal takes the removed one's slot, the last freed first, so { 3, 1 } less 3, plus 5, enumerates 5,1, and each set operation (UnionWith, IntersectWith, ExceptWith, SymmetricExceptWith, RemoveWhere), a copy and TrimExcess leave the slots where .NET's leave them. An element is found as its type's default comparer finds it, the rule a dictionary's keys take: a date, a decimal, a tuple and a record by value, NaN equal to NaN. Add answers whether the element was new, the set predicates, CopyTo and EnsureCapacity answer as .NET's, and an element added during a foreach ends the walk with an InvalidOperationException. TryGetValue is not handled yet and fails the build (EQ1004); a comparer that changes equality fails it too (EQ2007) (Since 0.2.0-preview.61).

•

✅ ContainsKey / TryGetValue never answer for "constructor", "toString" or anything else on Object.prototype. Since 0.2.0-preview.15; GetValueOrDefault too, since 0.2.0-preview.58.

•

✅ TryGetValue and GetValueOrDefault answer a miss with default(TValue) on every dictionary, the sorted ones included: 0 for an int, false for a bool, null for a reference, so d.TryGetValue(k, out var n); d[k] = n + 1; counts. The receiver, the key and an explicit default are each evaluated once, in the order written; an out _ receives nothing, and an out field or element is written where C# writes it. The static form, CollectionExtensions.GetValueOrDefault(d, key), reads the dictionary its first argument passes. Since 0.2.0-preview.58.

•

✅ Queue<T>, Stack<T>, LinkedList<T>, SortedSet<T>, SortedDictionary<K,V>, SortedList<K,V> → runtime compat collections under $eq.collections.*. A sorted one orders as Comparer<T>.Default orders its element type: a string in the current culture, a double with its NaN first, an enum by its value, a decimal, a date and a type of your own that implements IComparable by its CompareTo, and StringComparer.Ordinal by code unit. A queue's and a stack's Contains find a decimal, a date or a record by its value (Since 0.2.0-preview.60). Each writes the JSON .NET writes, an array in the order it enumerates, a stack from its top, so a Server Action argument reaches the server as the collection (Since 0.2.0-preview.61). A queue's and a stack's CopyTo, and a sorted set's CopyTo, UnionWith, IntersectWith, ExceptWith, SymmetricExceptWith, IsSubsetOf, IsProperSubsetOf, IsSupersetOf, IsProperSupersetOf, Overlaps, SetEquals and RemoveWhere answer as .NET's, their refusals in .NET's words, and of two elements a sorted set finds equal (1.0m and 1.00m) a union and an intersection keep the one .NET keeps. A null source handed to the constructor of a list, a queue, a stack, a linked list, a sorted set or any dictionary throws the ArgumentNullException .NET throws, naming collection or dictionary, where the browser built an empty one (a list threw a TypeError), a negative capacity of a queue or a stack is refused, and a string copied into one is read by its UTF-16 chars (Since 0.2.0-preview.62, #723, #726). A foreach over a queue, a stack, a linked list or a sorted set ends at the step after the collection changes, the one after the last element included, with the InvalidOperationException .NET throws, in .NET's words: a change is what .NET counts as one, a sorted set's Add of an element it holds and its Remove of one it does not included, and a value written into a linked list's node is none. A sorted set's Reverse() walks it from its largest element and is refused alike (Since 0.2.0-preview.62, #765). A queue's TryDequeue and TryPeek, a stack's TryPop and TryPeek and a sorted set's TryGetValue answer through their out as .NET's do, the type's default where there is nothing; an empty sorted set's Min and Max are its element type's default, as .NET's are; a queue's and a stack's Capacity, EnsureCapacity and TrimExcess keep .NET's capacity, grown by each one's own rule and sized from a sequence as .NET sizes it, to the count of an ICollection<T> and by doubling from four for anything else; a linked list's Find, FindLast, AddAfter, AddBefore and CopyTo, and the overloads that take a node, link as .NET's do, a node removed or cleared belonging to no list, with .NET's refusals in its words; and new LinkedListNode<T>(value) builds a node. Any other member of the five, a sorted set's Comparer and an explicit GetEnumerator among them, fails the build (EQ2004), where every member compiled and the ones the runtime lacked were a TypeError in the browser. A queue or a stack built from a LINQ query takes the query's count as its capacity, since the query has been read whole (#685) (Since 0.2.0-preview.62, #866). A sorted set's GetViewBetween answers a view of that range of the set, which shares the set's elements, each seeing what the other changes; it refuses an element outside its range and bounds out of order with .NET's exceptions, in .NET's words, and takes .NET's paths through the set operations, its ExceptWith asking the count it last counted, so it removes nothing until its count has been read, by Count, by LINQ, by a copy into a list or a set, or by a set's operation that asks it its count, as .NET's (Since 0.2.0-preview.64, #865). A sorted set's RemoveWhere asks its predicate in the set's order, where .NET walks its tree breadth first (#766). A LINQ query over a view counts it again, where .NET's First or Where only walk it, so its ExceptWith may remove what .NET's, with a count never read, leaves in place, and a list's AddRange does not count it, where .NET's does (#865).

System.Threading.Tasks

•

✅ Task, Task<T> → Promise.

•

✅ Task.Delay → setTimeout wrapper.

•

✅ Task.WhenAll, Task.WhenAny.

•

⚠️ Task.Run executes on the main thread (microtask), NOT a background thread.

Other Utilities

•

✅ Console.WriteLine → console.log.

•

✅ Math.* (Min, Max, Abs, Round, etc.) → Math.*.

•

✅ Guid (NewGuid, Empty, Parse, TryParse, new Guid(text)) → crypto.randomUUID() for a new one, and its canonical text, the lowercase D format, for one read from text in any format .NET reads, so two spellings of one Guid are one value to ==, a dictionary and a set (Since 0.2.0-preview.60).

•

✅ Regex → JavaScript RegExp.

🌐 Ecosystem Packages

eQuantic.UI.Lucide / Heroicons / RadixIcons / TablerIcons / Phosphor / SimpleIcons / BootstrapIcons / Iconoir / ...

Purpose: Comprehensive Icon Sets. Contains:

•

SVG resolution logic

•

Specialized icon components

•

A generated IconGlyph per icon, as a property so the trimmer can drop the ones nobody names

Package

Purpose

Status

eQuantic.UI.Charts

Charts written once, drawn by every realizer.

✅

eQuantic.UI.Lottie

High-performance animations.

✅

eQuantic.UI.Image

Optimized (Lazy/Blur/Priority).

✅

🧩 Framework Patterns

Pattern

Interface

Description

Status

Metadata Management

IHandleMetadata

SEO tags and head elements.

✅

Asset Management

IRequireAssets

Dynamic script/style injection.

✅

Server Actions

[ServerAction]

Secure RPC from Client to Server.

✅

Compound Components

N/A

Semantic sub-component patterns.

✅

Shared class library

ProjectReference

A type of a referenced project that a page uses is a module of the bundle: a static class, a record, a component and its strings. See Build Flow (Since 0.2.0-preview.62).

✅

⚠️ Limitations & Caveats

Blocking Code:

•

❌ .Wait(), .Result on Tasks are NOT supported. You must use await. Blocking the main thread freezes the browser UI.

Reflection:

•

❌ System.Reflection is largely unsupported.

•

✅ typeof(T).Name and nameof(...) are supported constants.

File System:

•

❌ System.IO (File, Directory) in code that crosses to the browser, a component's members on a stateful or a stateless page and every class a page reaches, is a build error (EQ2112): the browser has no file system to give it.

•

Use Server Actions to handle file operations: a Server Action's body and a [ServerOnly] member never cross, so they may read files.

Numbers:

•

✅ int/double/float map to JS numbers. Integer division truncates (Math.trunc), and a division or remainder by zero, or MinValue by -1 on int and long, throws the exception .NET throws (Since 0.2.0-preview.58); a float is rounded to single precision wherever it is produced, exactly as RyuJIT rounds it, a float? target's compound assignment and increment included (Since 0.2.0-preview.58), and Math.Round is .NET's: an exact midpoint, every MidpointRounding mode.

•

✅ decimal is exact end-to-end: compiled to the runtime Decimal compat type (BigInt mantissa + scale), so 0.1m + 0.2m == 0.3m is true. Decimals also cross the wire as **JSON strings (EqJson) and are hydrated back into Decimal** on the client (the field's Decimal default drives a type-preserving coercion, see hydrate-value.ts), so server-provided decimals keep all 28 digits instead of rounding through a double. A decimal read from text (decimal.Parse/TryParse, Convert.ToDecimal("…")) follows .NET's grammar under the NumberStyles the call names and rounds as .NET's parser rounds. It is read in the invariant culture, and the call says so with CultureInfo.InvariantCulture: with no culture the build warns (EQ2110) and with another one it fails (EQ2108), since the browser reads no other culture's text. A double or a float converted to a decimal keeps .NET's 15 or 7 significant digits: (decimal)(0.1 + 0.2) is 0.3. Since 0.2.0-preview.58.

•

✅ A constant is its value in its C# type: decimal.MaxValue, MinValue, Zero, One and MinusOne are exact decimals, spelled decimal or Decimal, and a long constant such as TimeSpan.TicksPerSecond is a BigInt, so it meets any other long. A decimal literal is its value, so 1_000.5m works, and a parameter's default filled in for an argument a named one skips keeps its type: a decimal, a long, a char, a string with a quote in it. A constant reached by its bare name under a using static is written the same way. A constant of an enum type is a value of that enum, not its number, and a decimal constant matches by value in a pattern, a switch arm or a case (d is 1m, case decimal.One:). Since 0.2.0-preview.60.

•

✅ Every other numeric type reads text as .NET does too: int, uint, long, ulong, short, ushort, byte, sbyte, double and float Parse/TryParse, and Convert.ToInt32("…") and its siblings, read the whole text under the type's own NumberStyles (Integer, or Float | AllowThousands for a real) or the one the call names. Text that is not a number throws a FormatException ("12abc", "1e3" as an int, "0x1F" without HexNumber), a value the type cannot hold an OverflowException, a failed TryParse leaves 0, a hex or binary style reads the type's bits ("FFFFFFFF" is -1 for an int), a long's text is a BigInt, and a float is rounded once, from the digits. The culture is decimal's: EQ2110 with none, EQ2108 with any but CultureInfo.InvariantCulture. Since 0.2.0-preview.58.

•

✅ A double's and a float's text is .NET's: the shortest digits that read back as the value, fixed notation from 1e-4 up to 1e16 for a double and 1e8 for a float, scientific outside (1E+17, 1E-05), -0 for a negative zero and Infinity for an infinity, the same through ToString(), ToString(CultureInfo.InvariantCulture), a concatenation and an interpolation; a null float? or double? writes nothing. Since 0.2.0-preview.58.

•

✅ A number's text with no specifier is the culture's, wherever C# writes it: a concatenation, a plain or an aligned interpolation hole, ToString(), Convert.ToString, string.Format("{0}"), string.Concat, string.Join, a StringBuilder's Append and Insert, and a record's text, as .NET writes them in the culture in force: -1,5 in pt-BR, a minus sign the culture spells (sv-SE's −5), a float in its own digits, a decimal with its scale, and never -0 for an integer JavaScript holds as a negative zero. A value written for a machine says so with ToString(CultureInfo.InvariantCulture), which keeps its shape in every culture. Since 0.2.0-preview.61.

•

✅ Through the formatter too: a float formatted with an alignment or a specifier ($"{f,8}", $"{f:G}"), ToString("G"), ToString("R") and a float passed to string.Format write its own digits, G and R in .NET's notation (1E+21). A string.Format placeholder aligns ({0,5}, {0,-5}), a null in an aligned hole is padded, and a params array passed whole, a string[] or a collection expression included, is its values. string.Format's provider follows the policy ToString has: CultureInfo.InvariantCulture formats invariantly, a date's patterns and the generic ¤ of a currency included, CultureInfo.CurrentCulture or a null as a call with none does, and any other is EQ2108. A bool's ToString() is True or False. One limit: a float boxed in an object the compiler cannot see through (object o = 0.1f; $"{o}", or an object[] built at run time) is the plain number underneath. Since 0.2.0-preview.58.

•

✅ A number prints through its specifier as .NET prints it: E and e write the mantissa's digits, the exponent's sign and at least three exponent digits ((12345.0).ToString("E2") is 1.23E+004). F, N, P, C, G and a custom picture round the number's EXACT value, a double's binary value included ((0.1).ToString("F20") is 0.10000000000000000555) and a long's and a decimal's every digit (9007199254740993L.ToString("N0") is 9,007,199,254,740,993), with an exact half rounded to even for a double and a float and away from zero for a decimal and an integer ((2.5).ToString("F0") is 2, (2.5m).ToString("F0") is 3, 125.ToString("E1") is 1.3E+002). N, F, C and P are laid out from the culture's own NumberFormatInfo, which travels with every page: its patterns, symbols, separators, group sizes and default digits ((1234.5).ToString("N") is 1,234.500 in en-US on a server whose .NET reads ICU), in ASCII digits in every culture, ar-EG's included, as .NET writes them (Since 0.2.0-preview.61). A culture switched to with no server to ask is laid out by Intl.NumberFormat v3 (ES2023): Chrome and Edge 106, Firefox 116 and Safari 15.4 have it. X and B (binary) write a negative integer at its type's width (((short)-1).ToString("X") is FFFF, an int's is FFFFFFFF). A custom picture is drawn as .NET draws it: sections (0.00;(0.00);'zero'), quoted and escaped text, % and ‰, exponents (0.00E+00), and the commas before the point that divide by a thousand (#,##0,). A precision can pass 100 digits, as .NET allows. Numbers are grouped as .NET groups them (es-ES writes 1.234) and signed with the culture's minus (sv-SE's −), and a specifier the type does not take throws, as in .NET ((2.5).ToString("D")). *Since 0.2.0-preview.59*. A double under D, X or B throws whatever it holds, nint and nuint are 64-bit integers, and the per mille sign (ar-SA's ؉), an exponent's signs and the percent sign are the culture's own. Since 0.2.0-preview.61.

•

✅ long/ulong are now exact: compiled to JS BigInt via the long compat helper. 9007199254740993L + 1L is 9007199254740994 (a plain JS number would round to …992). Literals become BigInt (5L → 5n), and so does a literal with no suffix that only a long holds (637000000000000000 → 637000000000000000n, Since 0.2.0-preview.58); arithmetic/comparison operands are wrapped in long() (which coerces number/string → bigint) so mixed expressions never throw. On the wire, 64-bit ints cross as JSON strings (Server Actions + SSR state, via EqJson) so values beyond 2^53 survive the round trip. Other numeric type suffixes (1.5f, 100u) are stripped.

Thread Safety:

•

Since JS is single-threaded, lock statements are compiled away (ignored).

•

Thread.Sleep is not supported (use Task.Delay).

🧪 .NET BCL Coverage & Conformance

Transpilation fidelity is enforced by a conformance harness (tests/eQuantic.UI.Conformance.Tests): each case runs the same C# expression two ways, transpiled to JS (executed via the embedded Bun) and evaluated directly in .NET (Roslyn scripting), and asserts identical results. A case whose C# the build refuses (an EQ error, such as EQ2008 for a query clause eqc does not lower) fails before either side runs, naming each refusal, unless it is written to pin that refusal: then it asserts the diagnostic's id and runs nothing. The suite counts its cases (over a thousand at the time of writing, and growing with every construct); all of them are green.

(Most recent: every dictionary through the runtime's dictionary class, $eq.collections.dictionary.) This covers both expressions and statement blocks (control flow: if/for/foreach/while/switch/ try-catch-finally/local functions; the block runs in an IIFE and its returned value is compared).

Every construct resolves via one of three mechanisms (see docs/DOTNET-COVERAGE-PROGRAM.md):

Native strategy: idiomatic JS when the runtime has an equivalent.

.NET-compat runtime helper: faithful .NET semantics where JS has none. The transpiler emits these under a single namespace $eq (organised by domain), brought in with **one import per module**, import { $eq } from "@equantic/runtime" (resolved by the page's import map), instead of N loose helper imports, and $eq.* can never collide with a user identifier in the generated scope:

•

$eq.num: dec (exact Decimal), decParse/decTryParse/decConvert (a decimal from text or Convert), intParse/intTryParse/intConvert and realParse/realTryParse/realConvert (an integer, a double or a float from text or Convert), decFromDouble/decFromSingle (a binary number into a decimal), long (Int64 via BigInt), double/single (a number's text)

•

$eq.math: round (banker's rounding)

•

$eq.convert: toBase64String, toBase64CharArray, toHexString, toHexStringLower (an array's encoding, as .NET's Convert writes it)

•

$eq.text: format (number/string formatting), stringBuilder, record and tuple (a record's, an anonymous object's and a value tuple's text, as .NET writes it)

•

$eq.time: dateTime, timeSpan, dateOnly, timeOnly, dateTimeOffset

•

$eq.enums: text, parse, tryParse, zero, names, values, isDefined (an enum as .NET reads it, from the shape eqc writes at each call)

•

$eq.collections: queue (FIFO), stack (LIFO), dictionary (held by slot as .NET's, keys found by identity or by value), linkedList, sortedSet/sortedDictionary/sortedList (key-sorted)

•

$eq.nullable: arith, cmp, unary (lifted Nullable<T> operators: null-propagating arithmetic and unary operators, false-on-null relational), through which a struct's own operators and conversions over nullable values are lifted too (Since 0.2.0-preview.64), and value (Nullable<T>.Value and every unwrap C# reads through it, which throws .NET's InvalidOperationException for an empty value; Since 0.2.0-preview.64)

•

$eq.equals: structural (value) equality for records/structs/tuples (backs ==, .Equals, Contains, Distinct)

•

$eq.hash: of (GetHashCode(), which agrees with $eq.equals, so values Equals finds equal hash equal, a vocabulary value type such as Point or TypeStyle included, and a type that overrides it answers its own), instance (the same call on a reference, refused when it is null as .NET throws NullReferenceException, while an empty Nullable<T> answers 0), group (the method group value.GetHashCode, which takes its receiver once and refuses a null one where the delegate is made), combine (HashCode.Combine, by its parameters even when they are named) and identity (object.GetHashCode of a class that does not override it, and an array's, however its items change). .NET's own numbers are not stable across processes, so the browser keeps the contract, never the server's number (Since 0.2.0-preview.60)

•

$eq.css: styleBuilder, classBuilder, joinClasses, whenClass (the styling subsystem)

Fail-on-unsupported: a construct with no possible JS representation now raises a build error (with a stable EQ code) instead of being silently emitted verbatim. Two layers:

•

UnsupportedConstructStrategy (EQ2001): typed-reference intrinsics (__makeref, __refvalue, __reftype), pointer types, function pointers.

•

goto/goto case/goto default (EQ2002): no JS equivalent; restructure with loops/conditionals. (unsafe/fixed/lock blocks unwrap to their body, lock being a single-threaded no-op, and a bare label drops to its inner statement.)

•

A name the browser lacks (EQ2004): a member no strategy translates, a method group whose call has none, a static or a construction of a PACKAGE's type (an assembly the build has no source for, whose types have no module and no twin) and a construction of a .NET type no strategy builds (new Random()), each refused where the code writes it, naming it (Since 0.2.0-preview.64).

•

The client/server boundary (EQ21xx): a call, a read, a construction, a method group or an extension of System.IO, System.Net.Http, System.Net.Sockets, EF Core / System.Data, OS threading (Thread/Monitor/Mutex), Process, InteropServices (P/Invoke) or Reflection.Emit in code that crosses, told once where the compiler writes it. (System.Threading.Tasks is not forbidden: async maps to Promise, and an exception of these namespaces is a value a page may throw and catch.) A Server Action's body and a [ServerOnly] member are never read as client code. The fix is to move the call into a [ServerAction].

Any other construct that hits no strategy is an error (EQ1001 for an expression, EQ1002 for a statement, EQ1003 for anything else) and nothing is emitted for it. It used to pass through verbatim with a warning, which meant a build that succeeded and a page that threw — refusing what it cannot represent is the whole point. Diagnostics print in MSBuild-canonical form, so they fail dotnet build and the IDE links them. The full list is in Diagnostics.

Area

Status

Notes

Arithmetic / bitwise / comparison

✅

integer division truncates; %, shifts, & | ^ ~ native for an int; a uint's & | ^ >> ~ stay unsigned, and a long's shifts mask their count to six bits and drop the bits past 64, as .NET's do (Since 0.2.0-preview.58); checked(expr) throws OverflowException, unchecked(expr) wraps to 32 bits (\| 0/>>> 0), a negation included, and an await inside either is the method's own (Since 0.2.0-preview.60). Default-context int overflow does not wrap (JS float64).

Math.* / MathF.*

✅

the same table as double.* / float.*, with .NET's own compositions; Round is .NET's (exact midpoint, every mode)

decimal

✅

exact via Decimal (literals + + - * / % == != < > <= >=, the remainder with the dividend's sign, Since 0.2.0-preview.58 for %); the constants MaxValue, MinValue, Zero, One and MinusOne (Since 0.2.0-preview.60); decimal.Parse/TryParse by .NET's grammar and rounding, the NumberStyles a call names included; Convert.ToDecimal and the casts from double/float at .NET's 15 and 7 digits

Numeric constants

✅

int.MaxValue, double.Epsilon, … → literals

Parsing / Convert.*

✅

Parse/TryParse on every numeric type, and Convert.ToInt32/ToInt64/ToDouble/… of text, by .NET's grammar (Since 0.2.0-preview.58); bool.Parse/TryParse and Convert.ToBoolean of text as .NET's Boolean.TryParse reads it: "True" or "False" in any case, trimmed of white space and NULs, and .NET's exceptions, and Convert.ToBoolean of a number as whether it is not zero, of a bool as itself, and of a char or a date as .NET's InvalidCastException (Since 0.2.0-preview.59); Convert.ToString/…; Convert.ToDateTime of a text as DateTime.Parse reads it in the culture the call names, a null one as MinValue (Since 0.2.0-preview.62, where it answered the text); Convert.ToBase64String, ToBase64CharArray, ToHexString and ToHexStringLower write .NET's encoding of a byte[], its offset, its length and its line breaks every 76 characters included, and refuse what .NET refuses in its words; a span that is not a collection expression fails the build (EQ1004) (Since 0.2.0-preview.62, where each wrote the array's 1,2,255)

Strings

✅

Substring/IndexOf/Replace/Split/Pad/Trim/Trim(char)/Concat/Format/Join/IsNullOrEmpty/IsNullOrWhiteSpace; Trim(chars) and its two halves read the string and then the characters once, an await among them included, and no characters (an empty or a null array) trims white space, as .NET does (Since 0.2.0-preview.60); Trim(), its two halves, IsNullOrWhiteSpace and a bare Split() read .NET's white space, where JavaScript's leaves U+0085 and takes U+FEFF (Since 0.2.0-preview.58); a string's own Equals, StartsWith, EndsWith, Contains, IndexOf and LastIndexOf (with a start and a count) and Replace given a StringComparison answer by that comparison, written out or held in a variable: OrdinalIgnoreCase keeps .NET's casing (the Kelvin sign, the long s and the dotless i are not k, s and I, and a surrogate pair is read as its code point), a start or a count outside the string throws .NET's exception, Replace writes its replacement as text, and CompareTo orders by the current culture, as string.Compare does (Since 0.2.0-preview.60). IndexOf and LastIndexOf of a string from a start, and for a count, with no comparison stop at their count, read LastIndexOf's start as the last char a match may cover, and throw .NET's exception for a range outside the string or a null value (Since 0.2.0-preview.62, where the count was dropped and LastIndexOf("bc", 4) answered the match beginning at 4). IndexOf(char, startIndex[, count]) and LastIndexOf(char, startIndex[, count]) search that range and throw .NET's exception for a start or a count outside the string: LastIndexOf's start stands on a char of the string, and an empty string answers -1 (Since 0.2.0-preview.61, where the start was clamped and the count dropped). A SEARCH by a culture comparison, or with a CultureInfo, fails the build (EQ1004), because the browser has no culture-aware search: search by Ordinal or OrdinalIgnoreCase, or compare whole strings with Equals or string.Compare. The overloads without a comparison search ordinally in the browser and by the current culture in .NET (#532).

char.*

✅

ToUpper/ToLower/IsDigit/IsLetter/IsWhiteSpace/… (Unicode-aware; IsWhiteSpace is .NET's set, U+0085 in and U+FEFF out, Since 0.2.0-preview.58; ToUpper, ToLower and their invariant pair case a char as a string of one, in the culture the call names, and a null culture throws .NET's ArgumentNullException, Since 0.2.0-preview.62)

StringBuilder

✅

compat type: Append(incl. bool→"True"/"False")/AppendLine("\n")/Insert/Remove/Replace/Clear/Length/ToString. The overloads that count or take a range write what .NET writes, Append('x', 3), Append(text, start, count), Insert(i, text, count), Replace over a range and ToString(start, length), a char[] as its characters and a null as nothing, and each refusal is .NET's (Since 0.2.0-preview.61). AppendFormat and AppendJoin append what string.Format and string.Join write, Capacity follows the chunks .NET allocates through every edit, MaxCapacity and EnsureCapacity answer, the Chars indexer reads and writes a char, Length cuts the text or fills it with \0, Equals(StringBuilder) compares the text, Equals(object) the reference (since 0.2.0-preview.64), and CopyTo copies it, each refusing what .NET refuses; an interpolated Append($"…") or AppendLine($"…") appends each part in turn, as .NET's handler does, so a hole that reads the builder sees the parts before it, a named argument is bound to its parameter, and a text longer than the browser's string can hold is .NET's OutOfMemoryException; a provider other than the current culture on Append, GetChunks and the span overloads fail the build (Since 0.2.0-preview.61)

CancellationTokenSource / CancellationToken

✅

the runtime's, as .NET's: a source (with a delay or none), its Token, IsCancellationRequested, Cancel, CancelAfter, Dispose and CreateLinkedTokenSource; a token's None (and default, and new CancellationToken(bool)), IsCancellationRequested, CanBeCanceled, ThrowIfCancellationRequested (an OperationCanceledException, "The operation was canceled.") and Register of a callback, whose registration Disposes and Unregisters. Callbacks run once, the last registered first, one registered late runs at once and is given back the default registration (its token is None), and the ones that throw are gathered into an AggregateException, as in .NET. A method of the three passed as a callback (token.Register(source.Cancel)) keeps its receiver, and a linked source, disposed, lets go of the tokens it follows. A disposed source lets go of its callbacks too, a registration still unregistering once after it, and new CancellationTokenSource(delay, timeProvider) fails the build with EQ2004: the runtime's source is timed by the real clock. A delay is taken up to 4294967294 ms, as .NET takes it, and a month is waited out though a browser's timer holds about 24.8 days. default(CancellationTokenRegistration) is the registration of nothing, whose token is None. Any other member of the three fails the build with EQ2004 (Since 0.2.0-preview.61)

LINQ

✅

Where/Select/SelectMany/Where-Select(indexed)/OrderBy/Distinct(By)/GroupBy/ToDictionary/ToLookup/Zip/Chunk/MinBy/MaxBy/Take(While)/Skip(While)/Aggregate/Sum/Min/Max/Average/Count/Any/All/First/Last/Concat/Reverse/Join/GroupJoin/ThenBy/ThenByDescending (Join/GroupJoin = order-preserving hash join over primitive keys; OrderBy+ThenBy = single stable composite sort, source copied). IGrouping from GroupBy/ToLookup is usable as a sequence (iterate, g.Select/g.Sum/g.Count()) and exposes g.Key; ILookup [key] indexer is not modelled. A comparer that asks for the default passes ToDictionary, ToLookup, GroupBy, Distinct and ToHashSet, and any other fails the build (EQ2007) (Since 0.2.0-preview.61).

Collections

✅

List, Dictionary, HashSet (incl. initializers and .Count; a set is the runtime's set, held by slot and finding its elements by value where its element type does, Since 0.2.0-preview.61); Queue/Stack/LinkedList compat; sorted family SortedSet/SortedDictionary/SortedList (key-sorted enumeration). Every dictionary is the runtime's dictionary class, $eq.collections.dictionary, enumerating by slot as .NET's does, a record/struct/tuple key found by value (construction and copy, d[k] get/set, ContainsKey/Add/Remove/Clear/TryGetValue/GetValueOrDefault/TryAdd/ContainsValue, Keys/Values/Count, foreach) (Since 0.2.0-preview.60). Reading a missing key throws KeyNotFoundException, and so do a compound assignment and an increment on one (Since 0.2.0-preview.58 for the increment). ILookup[key] indexer returns the group (or empty for an absent key). ICollection<T>'s Add and Clear reach the collection behind the interface, and IList<T> and IReadOnlyList<T> read and write a type of your own through its indexer and count it by its Count (Since 0.2.0-preview.61).

enum

✅

member-name string, a [Flags] enum its number (equality/switch/ternary, text and formats, the statics of Enum, Equals and GetHashCode by its underlying value, an alias as the member it aliases)

long/ulong

✅

exact via BigInt (long helper); literals 5L→5n, and constants too (TimeSpan.TicksPerSecond → 10000000n, Since 0.2.0-preview.60), wire as JSON string

DateTime

✅

tick-precise DateTime compat type: ctors, components, Add* to the tick as .NET 7+ lands on it (a fraction truncated, a count or a result out of range refused in .NET's words, AddMicroseconds included, Since 0.2.0-preview.59), -→TimeSpan, comparisons, .ToString()/format; ISO-8601 wire + hydration. ToString(), ToString(format) and ToString(format, provider) print as .NET prints them (no specifier, or a null or empty one, is the current culture's G, and no time zone moves the value's parts but U's): every one-letter standard specifier (d to Y, s, u and R from the value's own parts, o from them with the zone its kind names, U moved to UTC unless it is UTC already), a letter that is no standard specifier refused as .NET refuses it, a custom picture token by token with its fraction of a second (HH:mm:ss.fff), the culture's separators for / and : and the era for g (Since 0.2.0-preview.61), the invariant culture's patterns for CultureInfo.InvariantCulture or no culture in force, and a named culture refused at the build (EQ2108); ToShortDateString() and its siblings are d, D, t and T (Since 0.2.0-preview.60). Add, Subtract, AddMonths, AddYears and the + and - operators, compound forms included, refuse a result off the calendar in .NET's words, the operators naming their parameter t (Since 0.2.0-preview.60). Every constructor the compiler lets through builds the value .NET builds, each argument in its parameter's place, a named one included: the components with a millisecond, a microsecond and a kind, the ticks with a kind, and a DateOnly with a TimeOnly, a component, a kind or ticks out of range refused in .NET's words, and an overload that takes a Calendar refused at the build (EQ1004). A value carries its Kind (Now and Today local, UtcNow UTC, SpecifyKind), which arithmetic keeps and equality, ordering and the hash leave out; ToLocalTime() and ToUniversalTime() convert by it in the browser's time zone, Microsecond and Nanosecond answer, and the JSON writes a UTC value with Z and a local one with its offset and reads them back as System.Text.Json does (Z a UTC time, an offset moved to the browser's local time), while DateTime.Parse moves a written zone to the local time. A local time made from an instant keeps which of two repeated hours it is, as .NET keeps it beside the kind, through arithmetic until SpecifyKind, so its way back to UTC is that instant, and a date's text writes its kind: o and K end a UTC time with Z and a local one with its offset, and z, zz and zzz write the zone's offset for anything not UTC (Since 0.2.0-preview.61). Compare, Equals and UnixEpoch answer, and ToBinary, FromBinary, ToFileTime, FromFileTime and their UTC forms, ToOADate, FromOADate, IsDaylightSavingTime and GetTypeCode fail the build (EQ2004), where each named a member no twin had (Since 0.2.0-preview.64)

TimeSpan

✅

tick-precise TimeSpan compat type: From*, ctors, components/totals, + -, comparisons, .NET "c" .ToString(), and its standard and custom formats (Since 0.2.0-preview.62); Parse and TryParse read as .NET reads with no format, each part against its bound (Since 0.2.0-preview.62); "c" wire + hydration; Microseconds, Nanoseconds, TotalMicroseconds, TotalNanoseconds, Multiply, Divide, Subtract, Compare, Equals, *, / and a sign in front, a product or a quotient rounded to the even tick and a NaN or an overflow refused in .NET's words, and a sum, a difference, Negate and Duration past the range refused as .NET refuses them; TryFormat fails the build (EQ2004) (Since 0.2.0-preview.64); a factor of any type C# converts to a double, a long, a char and a nullable one included, which answers null when it is null, on either side, and *= and /= (Since 0.2.0-preview.64)

DateOnly / TimeOnly

✅

compat types (.NET 6+): ctors, components, Add*(+ TimeOnly wrap, one product converted as .NET 9+ converts a double, Since 0.2.0-preview.59, a DateOnly leaving the calendar refused in .NET's words, Since 0.2.0-preview.60), comparisons, ToString(), ToString(format) and ToString(format, provider) as .NET prints them in the culture in force: d and t with no format, the standard specifiers each type takes and a custom picture of its own parts, anything else .NET's FormatException, and ToShortDateString(), ToLongDateString(), ToShortTimeString() and ToLongTimeString() as d, D, t and T (Since 0.2.0-preview.61); ISO wire + hydration; a DateOnly's ToDateTime, and a TimeOnly's Add, IsBetween, ToTimeSpan, Microsecond and Nanosecond (Since 0.2.0-preview.64)

DateTimeOffset

✅

tick-precise compat type (wall-clock + offset, compared by the instant): ctors, components, MinValue/MaxValue (Since 0.2.0-preview.58), Offset/UtcDateTime/LocalDateTime, ToOffset, Add* to the tick with AddMilliseconds/AddMicroseconds, the clock time and then the UTC time refused in .NET's words (Since 0.2.0-preview.59), AddMonths and AddYears included (Since 0.2.0-preview.60), From/ToUnixTime* (ToUnixTimeSeconds and ToUnixTimeMilliseconds a long, rounded down before 1970 as .NET rounds it, Since 0.2.0-preview.61), - →TimeSpan, instant comparisons, ToString() and its overloads as .NET prints them in the culture in force: the short date, the long time and the offset with no format, every standard specifier but U, o and K writing the offset and u and R converting by it (Since 0.2.0-preview.61); ISO+offset wire + hydration. Every constructor builds the value .NET builds: the components with a millisecond and a microsecond, the ticks, a DateOnly with a TimeOnly, and a DateTime, which without an offset takes the browser's for a time that is not UTC; an offset that is not whole minutes, is past fourteen hours, or is not zero for a UTC DateTime is refused in .NET's words. Now is the instant at the browser's offset, LocalDateTime and ToLocalTime() read the browser's time zone, and Microsecond and Nanosecond answer (Since 0.2.0-preview.61). DayOfYear, TotalOffsetMinutes, ToUniversalTime(), EqualsExact, Compare, Equals and UnixEpoch answer, and ToFileTime fails the build (EQ2004) (Since 0.2.0-preview.64)

record / struct / value tuple

✅

Value semantics. Records/structs are instances of their twin classes (positional new Point(1,2) calls the constructor C# calls, and an object initializer is applied after it), tuples are arrays with element access by position (t.Item1) and by declared name ((int X, int Y).X) → index. ==/!=, .Equals, Distinct compare structurally via $eq.equals, and Contains, IndexOf and a set by the element type's default comparer, a tuple's array member by reference (Since 0.2.0-preview.61), and ==/!= over two nullable record structs compare by value too, two absent values equal and an absent one unequal to any value, as C# lifts them, where the browser compared two references (Since 0.2.0-preview.64), and so do .Equals, Nullable.Equals and EqualityComparer<T>.Default.Equals over a nullable record or struct, by its own Equals, never its ==, where the build refused them (Since 0.2.0-preview.64); with copies-and-replaces. A mutable struct and a value tuple are copied where C# copies them, so a write through one name never shows through another the value was assigned, passed, returned or boxed to: the twin copies on write, and copies this where it leaves its struct's member (Since 0.2.0-preview.61). Deconstruction var (a, b) = … works for tuples (array destructuring, discard holes) and records (object destructuring by Deconstruct order). Records emit as named JS classes carrying their user instance methods + a structural equals, prototype-preserving with, and .NET toString; value semantics are unchanged. A record's equals compares its runtime type (a Dog never equals an Animal), what its base compares and every field it declares, a private one included, and its text names the members .NET's PrintMembers writes, in its order: its base's members first, then its own, a computed property and a property whose getter has an accessibility of its own included, an override left to the base, each once, and Name { } for none. Two members of a record or a struct that land on one name of the twin (struct S(int x) { public int X … }, a field celsius beside Celsius) fail the build (EQ1007); a primary constructor's parameter read only by an initializer (struct Point(int x) { public int X { get; } = x; }) is the constructor's, and builds; an abstract property holds nothing. Each value is written as .NET writes it: a bool as True, an enum by its member's name, a null as nothing and a number in the culture in force, and a plain class or struct that writes no text of its own writes its type's full name (My.App.Outer+In), where the browser wrote [object Object] or a record's text; a generic one does not yet (Since 0.2.0-preview.61). A positional parameter whose property the record declares (record Box(int X) { public int X { get; set; } = X; }) is one member, the declared one (Since 0.2.0-preview.61). A member starts as its declaration says, whatever the expression: a positional parameter, a property's or a field's initializer (= 1.5m, = 5 on a long, = new(), = "#" + Id), written once, in the class's constructor (Since 0.2.0-preview.59), which runs every initializer on every construction, whatever an object initializer then sets (since 0.2.0-preview.61; see Constructors above). A record's and a struct's members are lowered as a class's are: an async method, an iterator, an out or ref parameter, and the variable an expression body's pattern binds (o is P p && p.X == X) work in their methods, operators, conversions and computed properties, their own and a default an interface supplies, and a getter that yields returns its sequence in a class too (Since 0.2.0-preview.60). The build pipeline discovers records by scanning and emits each as its own module; components that reference a record import it automatically (reactive, no hardcoded list). SSR values are re-hydrated back into the record class on the client (recursively, restoring nested records and compat members), so methods/instanceof survive. Covers positional and body records and plain structs, plus record inheritance (extends + super) and generic records, whose equality compares the closed type a value was built as: a Box<int> never equals a Box<double>, and one built inside generic code, whose type arguments the build cannot know, is not taken for another type (Since 0.2.0-preview.61). Record-keyed dictionaries (Dictionary<RecordKey, V>) find a key by value, so equal-by-value keys collide as in .NET. Each member compares as EqualityComparer<T>.Default compares its type, so an array, a list or a collection's interface (IReadOnlyList<int>) by reference, and a tuple's Equals compares its elements the same way, a tuple of another arity unequal and a null pair equal only to another; a tuple seen only as object, or as an interface a tuple implements, is an array on the web and compares by its elements (Since 0.2.0-preview.61). A value tuple's text is .NET's, (1, a): each element as its type writes it in the culture in force, a nested tuple and an anonymous object included, a null one as nothing, and eight elements or more flat, through ToString() and its method group, a hole (one with an alignment or a format too, which a tuple ignores), a concatenation, string.Concat, string.Join, string.Format, a StringBuilder, Convert.ToString and a record's member, Zip's pairs among them, where the browser wrote 1,2. An element that is an array, a list, a dictionary, a set or a delegate writes its type's name, System.Int32[], as .NET does, and so does the value itself wherever it is written into text, where the browser wrote 1,2 or a function's source. Its ToString method group writes the same, and an enum's group its member's name, where the group wrote JavaScript's text. Equals(object) finds a tuple of other element types unequal, ((byte)1, 2).Equals((object)(1, 2)) is false, where the browser saw the same array. The method group t.Equals compares as the call does, and a Nullable tuple's Equals is its value's (Since 0.2.0-preview.64). A tuple held as object, whose type the build cannot see, still prints 1,2 and compares by its elements, and so does one handed to the Equals method group's delegate.

Anonymous object (new { A = 1 })

✅

A plain object, its members under their twin names ({ a: 1 }). Equals, a call or a method group, compares as the Equals C# writes for an anonymous type: each member by its own type's equality (an array or a list by reference, a decimal and a tuple by value), and only another anonymous object of the same members in the same order can be equal, so other members, the same members in another order and a record with the same members are not. The call threw before. Members of other types make another type too: new { A = (byte)1 }.Equals(new { A = 1 }) is false. Through null, Equals, ToString and making the delegate of either method group throw NullReferenceException, as in .NET, while a hole and a concatenation write nothing. == stays reference equality, and GetHashCode hashes equal objects equal, and a set, Distinct and GroupBy find equal objects one key, Distinct keeping the first of each. Its text is .NET's, { R = 255, Name = a } and { }: the C# member names in their order, each member as its type writes it in the culture in force, through every route a tuple's text takes, where the browser wrote [object Object] (Since 0.2.0-preview.64). One held as object, or handed to the Equals method group's delegate, still prints [object Object] and compares by its members, whatever their types.

object members

✅

object.Equals(a, b) answers as .NET's: true for two nulls or one reference, false for one null, and otherwise the FIRST argument's own Equals, chosen by its type before C# boxed it and found by parameter, so Equals(objB: x, objA: y) asks y, both evaluated as written; a value of a type that refuses every other (a number, a char, a bool, an enum, a tuple, a string, an anonymous object) is unequal to one known to be another, so object.Equals((byte)1, 1) and object.Equals('a', "a") are false. Equals(object) inherited from object compares an array, a list, a StringBuilder and a class that does not override it by reference, and asks an override wherever one exists, as a call, a method group or a bare Equals(x) in the class. Equals and ToString through a null reference (a record, a class, a string, an interface, object) throw NullReferenceException after the argument is evaluated, where a hole and a concatenation of a null write nothing. GetType() and MemberwiseClone() fail the build (EQ2004), once for a chain read from one (x.GetType().Name) (Since 0.2.0-preview.64). A list, an array, a tuple or an enum held as object on both sides has lost the type .NET reads, since the browser holds the first three as one array and an enum as its member's key, so two lists or two arrays held so compare by their elements, as two tuples do, and a boxed enum equals its key's string.

Nullable<T> (T?)

✅

HasValue/Value, GetValueOrDefault() (type-aware default: 0/false/$eq.num.dec(0)/enum zero-member/…) and GetValueOrDefault(fallback), ??; lifted operators via $eq.nullable.*: arithmetic propagates null, relational (< > <= >=) is false when either side is null (not a numeric coercion); a compound assignment (+=, *=, …), an increment and a unary -, ~ or + on a nullable number are lifted too, a null staying null and a value following its type's rule (a float? rounds, a byte? wraps, a decimal? stays exact; Since 0.2.0-preview.58). A struct's own operators and conversions are lifted the same way, the operator running only over values: == finds two absent values equal and an absent one unequal to any value without it, a relation is false and every other operator null, and one declared over the nullable values themselves is called as written (Since 0.2.0-preview.64). Value on an empty one throws InvalidOperationException ("Nullable object must have a value."), as does every unwrap C# reads through it: a cast to the value's type or another, the value a struct's own conversion operator takes, and a foreach element of a type that is not nullable. Equals, Nullable.Equals and EqualityComparer<T>.Default.Equals answer as the lifted == does, two empty values equal and an empty one unequal to any value, and the ToString method group writes what its call writes. A struct's own Value, HasValue, GetValueOrDefault or Count, read through ?. or a property pattern, is the struct's (Since 0.2.0-preview.64). No-arg GetValueOrDefault() on DateTime?/Guid?/struct yields null, so use the fallback form there.

Guid

✅

Guid.NewGuid()→crypto.randomUUID(), Guid.Empty, Guid.Parse/TryParse/new Guid(text) → the canonical lowercase D text (Since 0.2.0-preview.60); string wire

PREVIOUSCompiler

NEXTExternal Type Resolution

ON THIS PAGE

🏗️ Core Language Features

System.DateTime, TimeSpan, DateOnly, TimeOnly & DateTimeOffset

System.Collections.Generic

System.Threading.Tasks

Other Utilities

🌐 Ecosystem Packages

eQuantic.UI.Lucide / Heroicons / RadixIcons / TablerIcons / Phosphor / SimpleIcons / BootstrapIcons / Iconoir / ...

🧩 Framework Patterns

⚠️ Limitations & Caveats

🧪 .NET BCL Coverage & Conformance