tps --watch rebuilds the site whenever a source file changes, in the root project or in any project it references, and serves the result over a local development server (--watch-port, default 4300). The page it serves reconnects over a websocket and reloads itself after each rebuild, so the edit-and-see loop needs no manual build or refresh. See Watch mode.

When every file in a batch of changes is a source of a stylesheet the last build already produced, the CSS is re-copied and the page swaps it in place instead of reloading. The running application keeps its state: open panels stay open and the current route stays put. Anything else is a real rebuild.

The MSBuild SDK now passes --incremental, so an ordinary dotnet build reuses the previous build of each project: nothing is compiled when every input hashes the same, and a body-only edit keeps the cached JavaScript of every untouched type. The output is byte-identical either way. Turn it off for a project with <TransposeIncremental>false</TransposeIncremental>. A build's output is also recoverable, so a cache that goes missing only costs a full build.

Transpose.Compiler.Library compiles C# to JavaScript in-process: compile in-memory sources, build a real .csproj, or drive the same watch loop from a host that runs its own web server. It ships at the same version as Transpose.Compiler, from the same release.

When two members of a type resolve to the same emitted name, only the last would exist at runtime and which one survived depended on declaration order. The compiler now reports TransposeR0003 and names both members. C# overloads cannot trigger this, since they take numbered slots, so it means two members carry the same explicit [Name].

Copying a struct that itself holds struct-typed fields now clones those fields too, so mutating the copy no longer writes through to the original. The object and collection initializer paths that previously skipped the copy are covered as well.

It is no longer left undefined until first assigned.

Home = { City = "x" }, Tags = { "a", "b" } and Scores = { ["k"] = 7 } apply to the member's current value rather than assigning a new one. The first two used to emit an array literal that overwrote a getter-only collection, and the indexed form failed to translate at all.

.NET gives every value type field-wise Equals and GetHashCode, which is what makes a struct usable as a dictionary or set key. Only records synthesized them before, so a plain struct fell back to reference identity and a lookup for a key just added threw. Both are now synthesized over the struct's instance fields unless it declares its own.

== and != on two separately constructed DateTime values with the same instant used to be unequal, and lifted DateTime? equality had the same problem.

A hand-written ToString or PrintMembers is now used instead of being ignored, and a derived record chains to its base. The output covers public fields as well as public readable properties, excludes non-public members, prints an overridden member once rather than twice, and renders a char as its character and an enum as its member name rather than as numbers. The char and enum fix applies to plain string concatenation too.

This is what C# does, so a public field now participates and a computed property no longer does. Previously record Node(int V) { public int[] Cache => new[] { V }; } compared two equal values as unequal, because each read of Cache allocated a new array. Equals(object) delegates to the typed Equals, so a record's own Equals and GetHashCode govern ==, dictionary and set membership alike.

Optional positional parameters now take their defaults, a positional parameter no longer clobbers a member the record itself declared, and a record struct's implicit parameterless constructor is emitted so new S() works. with on a record with a get-only computed property no longer throws. A plain struct's parameterless constructor gained the same fix: it zeroes the value rather than running declared field initializers, matching C#.

Both overloads coexist and a call site resolves the one it bound.

new Point(1, 2) on [ObjectLiteral] record Point(int X, int Y) emits {X: 1, Y: 2}; it used to emit an empty object and drop them.

That is C#'s order for every derived type. A synthesized or primary constructor ran them after the base call, so a base constructor observed the derived fields still at their defaults.

.NET gives each declaration its own backing field, reachable across levels only through virtual dispatch. Collapsing them into one location meant a base initializer landed on the override's value and no read dispatched. A non-virtual auto-property is unchanged.

A property read or write through base used to run the most-derived override, which is exactly what base is meant to bypass.

A parameter, local, out var, foreach or catch variable, or query range variable with the same name as a type no longer hides it, which previously produced a call against the local and failed at runtime.

A ToPromise() extension binds the runtime adapter the compiler already uses for await, so a C# task crosses into JavaScript as a thenable. A faulted task rejects the promise rather than dropping the exception, and the handler receives exactly the task's result.

SetsRequiredMembers is a compiler-required member, so a required member did not compile at all without it. AllowNull, DisallowNull, MaybeNull(When), NotNull(When/IfNotNull), DoesNotReturn(If) and MemberNotNull(When) carry no runtime behaviour but likewise had to exist for annotated code to compile.

A sequence of non-string values now formats the way it does on .NET.

A timestamp ending in .25 read as 25 milliseconds instead of 250, so a round trip through a date string did not return the original value.

An array reports its type name (System.Int32[]) instead of its joined elements, so "" + new int[] { 1, 2 } no longer gives 1,2. A DateTime reports the culture's general date and time pattern instead of the JavaScript date string, a Type reports its display name, and a type with no ToString of its own falls back to its type name with generic arguments named plainly.

Every case in the suite now runs twice, once natively against Json.NET and once as translated JavaScript, and the outputs are diffed, so a divergence has to be deliberate and is recorded. Building it out corrected several behaviours: DefaultValueHandling.Ignore drops null members; the camel-case resolver lowercases a leading run of capitals the way Json.NET does (ALLCAPS becomes allcaps); TypeNameHandling.Auto writes the type name again; a type name that does not resolve is ignored rather than fatal when the caller did not ask for type names; an empty or whitespace-only document deserializes to the default value; and System.Version round-trips as its 1.2.3.4 string. The remaining documented differences from Json.NET are listed in the JSON serialization guide.

A payload using Json.NET's lenient syntax (comments, single quotes, unquoted names, trailing commas) previously fell back to the JavaScript evaluator, which a Content-Security-Policy without 'unsafe-eval' blocks outright. It now goes through a hand-written reader, so the package works under a strict policy. The reader is also slightly stricter, matching Json.NET in rejecting undefined, a leading + on a number and a signed hexadecimal literal.

Even when the binder is implemented implicitly, which covers interface-typed arrays, an interface-typed member nested in such an array, a null polymorphic slot, and an outer type whose only constructor takes arguments.

A tps.json resource group takes "load": false, which still writes the file into the output and still embeds it into a package, but leaves loading it to the application: a module fetched on demand, or a stylesheet swapped in at runtime. The legacy .dontload name suffix keeps working, and either spelling alone suppresses the injection. The flag travels in the package's resource manifest, so a project referencing the library extracts the file without auto-loading it either. See Resources.

Every assembly the compiler produces records the compiler that built it and the oldest compiler allowed to consume it. Before compiling, the compiler checks every assembly the project binds against and fails with TPS0008 if one needs a newer compiler, naming the version required and the command that installs it. Because a package's real payload is JavaScript and the consuming compiler decides how emitted code binds to it, an older compiler fed a newer package would otherwise produce a subtly wrong bundle instead of an error. Assemblies published before the stamp existed are skipped, so older packages keep working.

Two projects in one build can no longer bind different versions of the same package.

A stale copy in the package cache no longer wins over a newer one.

Loading it kept the file locked for the process's lifetime and resolved by assembly identity, which is what made the second rebuild of a multi-project app in watch mode fail to write its assembly and made a rebuilt library's resources come back stale.

Whether outputBy: ClassPath selects the runtime build is decided by the project's assembly name. The previous test looked at whether the base library appeared among the resolved references, which it never does (the compiler injects it), so any project whose Transpose.BCL package was not yet in the NuGet cache was compiled self-contained and failed on every predefined type.

tps --incremental reuses the previous build of a project: a build whose inputs all hash the same does no work at all, and an edit confined to method or accessor bodies reuses the cached JavaScript of every type it did not touch, the reflection metadata and, in a metadata-only configuration, the emitted assembly. The output is byte-identical either way, and the cache lives in the project's obj/.

Transpose.BCL, Transpose.Core, Transpose.Newtonsoft.Json and Transpose.HttpClient are now on NuGet, so a project can reference the toolchain rather than build it.

outputFormatting selects Formatted, Minified or Both. When both variants exist the build configuration decides which is wired into the generated page: Release keeps the minified page as index.html, Debug the readable one. Authored resources are never re-minified, only Transpose-emitted JavaScript is.

DEBUG (in a Debug configuration), TRACE and the framework-derived symbols are also defined implicitly, matching the .NET SDK.

C# locals are emitted with let so two sibling blocks can each declare the same name, a loop body captures a fresh variable per iteration, and a local no longer collides with a variable declared inside a Script.Write block.

A non-primitive struct field or expression now defaults to a zeroed struct rather than null, a struct's nested struct fields are zero-initialized, and default(T) in a generic method and a static struct field both produce the zeroed value.

Narrow integer arithmetic that promotes to long now produces a real 64-bit value, primitive-type casts were corrected, user-defined conversions declared in a referenced library or in the base library are now applied, and a conditional expression lifts a narrow branch to the expression's own type.

Enum members are emitted as plain JavaScript numbers, which hold integers exactly only up to 2^53, so enum E : long { X = long.MaxValue } quietly took a different ordinal and members far apart above that limit could collide onto one value. Declaring one is now a clear error instead; int, uint and narrower underlying types are unaffected, and a referenced assembly can still expose a 64-bit-backed enum.

They never resolve to a call to a user-defined operator.

Doubled braces in an interpolated string are unescaped, alignment specifiers are honoured, a null operand in a concatenation is treated as the empty string, and an interpolated string converted to FormattableString or IFormattable goes through the factory.

Bare type patterns, boxed-enum type tests and extended property-pattern paths now resolve correctly, as do a positional argument following a named one, a single element passed to a params parameter by name, params pass-through, an omitted optional argument before a params parameter, and named or optional arguments in a call with ref or out arguments.

For-loop closure capture, foreach disposal, foreach over null, extension GetEnumerator, iterator local functions, and inline variable scoping inside foreach were all corrected.

An await inside an out or ref call, an object initializer or a reordered argument list no longer breaks the bundle's syntax.

Constructor metadata carries the right attribute visibility and slot, attributes are constructed through the overload actually applied, references to delegate and method type parameters resolve, and PropertyInfo.CanRead / CanWrite report correctly.

[Namespace], [Reflectable], [Script] and [Conditional] are implemented; the two-argument [Template] form for non-expanded params is honoured, as is a [Template] on a method group; a [Convention] on the implementing type applies to interface-implementing methods; the enum name-casing modes were fixed; and [Transpose.Ready] static methods are registered to run when the page is ready. Every attribute and its status is catalogued in the attribute reference.

A call whose argument is dynamic now inlines, and an inline lambda argument is parenthesized so it is safe wherever the template places it.

A native error thrown by library code now carries its stack into the .NET-shaped exception.

A runtime type test against an array now reports correctly.

It no longer emits an application with unbound type parameters.

A tuple literal used to be a plain object, so ToString() printed [object Object] and Equals and GetHashCode threw. Tuples now print as (a, b) and work as dictionary and set keys. Element access, deconstruction, named elements and == are unchanged.

The evaluation order of named arguments also now matches C#.

Inlining baked the value into every consumer, so updating a base package without rebuilding everything in between left the old value behind. A read now resolves against whichever build of that package is loaded. Consts are emitted as static fields.

new T(a, b, c) on such a type used to emit an empty object literal, dropping both the constructor and its arguments.

Only locals and parameters were bound correctly; a field, a static field, this.F, obj.F, arr[i] or map[k] on the left of a deconstruction was mis-emitted or dropped outright.

A member whose name collided with a JavaScript function property (name, length, …) was renamed to an identifier nobody declared; members of a [GlobalMethods] binding are the ambient globals themselves and are now emitted bare.

Task.Yield, string.ToLowerInvariant and ToUpperInvariant, and the LINQ operators Chunk, MinBy and MaxBy.

Along with the 64-bit representation bugs behind it.

Each call produces a distinct value.

Like .NET's other integral Convert methods they round half-to-even rather than truncating, so Convert.ToInt64(42.7) is 43. A truncating (long) cast is unaffected.

Sum over a sequence containing nulls totals the non-null values instead of returning null, and Average, Min and Max return null only when there is no non-null value at all, rather than throwing. A selector is applied first, so items.Sum(x => x.MaybeNull) drops the projected nulls. The non-nullable overloads keep their own contract.

Dictionary now dispatches Keys and Values through the interface correctly, IComparer<T>.Compare resolves, and delegates combine and remove through the binary + and - operators.

bool.ToString() casing and nullable-enum ToString() were corrected, as were the runtime operator methods for non-external base-library structs such as DateTimeOffset.

Array type arguments and ISerializationBinder dispatch were corrected, a JSON array now deserializes into an IEnumerable<T>-only target, and an [ObjectLiteral] type is returned raw instead of being deep-deserialized.

A generic method in such a library emitted a body that referenced its type parameter without receiving it, failing at runtime. Libraries whose package id starts with Transpose. but which are not the base library are the affected case.

Transpose.Howler, Transpose.P2 and Transpose.WebGL2 carried a stale copied configuration that pointed at files they do not have, which produced a generic, collision-prone bundle name. They now emit Transpose.Howler.js, Transpose.P2.js and Transpose.WebGL2.js.

Errors and warnings are printed in MSBuild's canonical format, so a compile error lands in the IDE error list and is navigable to the file and line. Every error is reported by default, ordered by file and line, with --max-errors to cap the output.

The resolver follows <Import> transitively, so a shared project's compile items are picked up.

After a successful build, files left over from a previous build that this build did not write are removed, scoped to files the project itself authored. A failed build leaves the previous output intact.

The compiler reports per-phase and per-type progress, and --timing prints a per-phase time and allocation breakdown.

Because a Transpose assembly is only ever bound against and can never execute, the emitted assembly can carry full metadata with no method bodies. This is the default in Debug and is worth about 18% of a build; Release emits real IL, and the SDK refuses to pack a Debug build so a metadata-only assembly cannot reach a NuGet feed. DebugType is honoured.

Each reference assembly's resolved path is now logged as well.

A package's resource output subdirectories are preserved on extraction, a tps.json resource that self-references the project's own compiled output is honoured, a file with no minified variant is kept in the minified page, and package CSS and binary resources are no longer fed to the JavaScript minifier.

This is what lets the binding libraries publish.

For a ?? operand mixed with && or ||.

The win comes from the compiler's runtime configuration, a cheaper feature scan and fewer redundant binds.

After caching the naming layer and rewriting its hot paths, and per-symbol allocations during emit are down.

The emitted assembly is also written once rather than twice.

That takes about a second off every invocation. dotnet tool install resolves the right build for your machine, and the release pipeline verifies the property cannot be lost silently.

The translator is a clean-room rewrite that binds with Roslyn and emits JavaScript directly from the C# syntax tree, so browser code now gets the same type checking, generics and error messages as the rest of a .NET solution. The legacy translation pipeline is gone.

A project references the Transpose.Build.Target MSBuild SDK, which runs the tps compiler once per project. There is no global-tool compiler to install and no compilation server to keep running. The output is a runnable site: the tps.js runtime, the JavaScript bundle, the reflection metadata, your resources and a generated index.html.

Transpose.BCL is built into the tps.js runtime and a Transpose.dll reference assembly that carries the runtime as an embedded resource, giving a core library with zero assembly references that doubles as the only base-library reference a project needs.

The runtime global in emitted JavaScript is Transpose (language helpers are reached through TransposeR), the runtime bundle and config file are tps.js and tps.json, the compiler command is tps, the codegen attributes live in the Transpose namespace, and the Web bindings in Transpose.Core. Package ids are Transpose.*, with the base library published as Transpose.BCL (its assembly stays Transpose). A step-by-step porting guide is available in the migration guide.

Classes, structs, records and record structs; interfaces with both implicit and explicit dispatch; generics with runtime type-argument threading, including new T(); pattern matching, tuples and switch expressions, including C# 11 list patterns and property patterns; iterators; local functions; events and multicast delegates; user-defined operators and conversions; goto and labels, including across an await; block-scoped using declarations; and Index / Range on arrays.

C# 12 primary constructors and collection expressions, the C# 14 field keyword, params collections, ref returns, and multidimensional arrays. LangVersion defaults to latest.

An async method is emitted as a native JavaScript async function and its result is returned as a runtime Task, so awaiting a JavaScript promise from C# and handing a task to JavaScript both work. ValueTask is treated like Task.

Query expressions compile to the same operator chain, including join, group by, let and into continuations.

32-bit integer arithmetic wraps as it does on .NET rather than silently turning into a float, lifted nullable operators propagate null, and the conversions to and from the exact 64-bit and decimal types are emitted rather than erased.

Assigning, passing or returning a struct declared in the project being compiled clones the value rather than aliasing it.

Types and members carry metadata that backs System.Reflection at runtime, emitted either to a separate .meta.js file or inline in the bundle.

[External] (including at assembly level), [Name], [Template] with {this} / positional / named substitution and out and ref write-back, [Script], [ObjectLiteral], [Enum] in all nine emit modes, [Convention], [GlobalMethods], [GlobalTarget], [ExpandParams] and [IgnoreGeneric], plus the .NET [Flags], [Conditional] and [ModuleInitializer]. See the attribute reference.

Script.Write injects its code verbatim, with positional substitution of the surrounding C# arguments.

A P/Invoke declaration or an inline array now fails the build with a clear diagnostic instead of emitting code that cannot run in a browser.

Overloads take numbered slots, constructors past the first are named factories, and inherited or explicit [Name] values, object-method overrides and interface member names resolve in a fixed order, so the emitted surface is predictable.

Transpose.BCL provides System.String and the numeric types, the generic collections (List<T>, Dictionary<TKey, TValue>, HashSet<T>, Queue<T>, Stack<T>, …), LINQ, System.Text and composite formatting, regular expressions, Console, Task, Activator and the reflection surface, alongside DateTime, TimeSpan, Guid and Random.

They are implemented as runtime types rather than JavaScript numbers, so a 64-bit identifier or a monetary amount survives arithmetic and a round trip without losing precision. Note that they are therefore objects at the interop boundary, not numbers.

== and != on a non-primitive struct such as TimeSpan or DateTimeOffset compare by value, and TimeSpan arithmetic goes through the runtime's own operators.

Enumerator resolution handles the shapes the base library and user code produce.

Strongly typed definitions for the DOM (Transpose.Core.dom) and the ES5/ES6 standard library (Transpose.Core.es5): elements and events, XMLHttpRequest, Canvas, JSON, Promise and the rest. Everything in it is external, so it adds nothing to the bundle beyond the calls you make.

A library marked [assembly: External] compiles to a package of pure bindings with no emitted bodies. This is how Transpose.Core above and the JavaScript-library bindings (Transpose.Newtonsoft.Json, Transpose.HttpClient and the rest) are built, and it is available for binding a library of your own.

--emit-package produces a .NET assembly with the compiled JavaScript and the tps.json resources embedded, for other projects to reference; --separate-assemblies makes a consuming build extract that embedded JavaScript instead of recompiling the library's sources. A referenced project is built first and then reused.

--reference for an assembly outside the NuGet cache, --define for a preprocessor symbol, --assembly-version, and --build-runtime with outputBy: ClassPath for building the runtime library itself. See the CLI reference.

output, fileName, html and reflection control where output goes, what the generated page contains, and whether reflection metadata is emitted. See Global Configuration.