Software architect in the .NET space since the framework's inception — two-time startup employee #3. I design spec-first, plan-second, code-last: specs are cheap to rewrite, code isn't, so every incongruence gets sorted before a single line is committed to. Once code ships, the philosophy doesn't change — compile-time enforcement over runtime guessing, no silent fallbacks, fail loudly and immediately, and naming as a deliberate act, never an afterthought. The pit of success: the easy path and the correct path should be the same path.

The repos below are where that ethos ships in the open.

A zero-dependency .NET library for generating RFC 9562 compliant, time-ordered UUIDs. Produces UUIDv7 (millisecond precision), UUIDv8 (tick precision), deterministic UUIDv5/v8 name-based, and random UUIDv4 identifiers — all with SQL Server sort-order support and built-in timestamp extraction. Ideal for reducing clustered index fragmentation while retaining the global uniqueness and merge-safety of standard UUIDs.

A lightweight .NET library that lets you await a tuple of tasks and destructure the results in a single line. Supports up to 16 tasks with mixed return types, ConfigureAwait, and .NET 8+ ConfigureAwaitOptions — no Task.WhenAll boilerplate required.

A reference .NET platform — Norse.* — built as composable realms. Repositories carry the lore; namespaces carry the function: open the org and tour the cosmos, open the .slnx and every project says what it does. Each realm ships independently; mix in the realms you need, write your own .NET Aspire AppHost, and compose your own platform on the same substrate.

The rainbow bridge between the realms, watched over by Heimdall. Clone with submodules and the whole platform comes up running:

git clone --recurse-submodules https://github.com/NorseArchitecture/Bifrost.git

Advanced development programs for native-core, polyglot performance — with receipts. The Hyper* series is small, hyper-performance Rust cores, written once and called directly — not wrapped, not shimmed — from C#, Java, Go, Swift, Ruby, PHP, and Python. One implementation, one set of test vectors, every language, every platform.

The architecture never changes: a single Rust cdylib with zero runtime dependencies and a plain C ABI, built without Rust's standard library so what ships is 17–293 KB per platform, reached from each language over its own direct door — P/Invoke, FFM, cgo, Fiddle, PHP's FFI — or linked straight into the VM as a native extension (PyO3 for CPython, Magnus for CRuby). No runtime bridge, no serialization layer, no sidecar, no embedded interpreter.

And it is proven, not configured — all the way out to the browser. Every binding but Java and PHP compiles to WebAssembly with the core linked in by its ecosystem's own toolchain — the Rust crate on wasm32, C# under Blazor with nothing more than a PackageReference, Python under Pyodide, Go through TinyGo, Swift through its WebAssembly SDK, Ruby through ruby.wasm — and CI runs every one of them in headless Chrome. Java has no browser route, because no Java-to-wasm compiler has the FFM API the binding is built on, and PHP is proven in the browser on WordPress Playground's runtime but not shipped. C# publishes under PublishAot on all five CI legs, Java survives a real GraalVM Native Image build, and every binding's actual test suite runs on real hardware — linux and windows on x64 and arm64, macOS on arm64 — against that leg's freshly built native library.

Every performance claim is a measured receipt, and the losses print next to the wins. Go is the control group: cgo charges ~50 ns per crossing against a genuinely excellent stdlib, so Go loses per call and the scoreboard says so — which is exactly what makes the rest of it credible.

The identity round. One allocation-free RFC 9562 UUID engine — v4, v5 and v7 generation, the SQL Server uniqueidentifier byte order as a v8, batch generation — reached from inside every host language's own process. As fast as the platform's own UUID call or faster in every roster language except Go:

The batch API collapses a thousand FFI crossings into one: 1,000 v7s cost 5.7x less in Rust, 6.2x less in C# and 10x less in Go than the same thousand calls.

The trust round. Allocation-free parsers that turn untrusted text into strongly typed values — booleans, numerics, exact decimals, UUIDs, temporals, durations, Excel serials. Every runtime already has TryParse; what it hands back is a bool and a shrug. Every HyperCast door returns a Verdict instead: the value, or a closed reason code plus the exact byte span that offended. Never throws, never allocates, never guesses a culture — and a shared conformance corpus makes every binding agree byte for byte.

It beats the platform's culture-machinery parsers and says so where it only draws with or loses to their single-shape C builtins: RFC 3339 timestamps 2.2x faster than DateTimeOffset.TryParse, 11.0x Instant.parse, 17x Swift's Date.ISO8601FormatStyle, 6.7x Time.iso8601, and a messy 1/7/2026 3:04 PM 20x faster than Python's strptime.

The ingestion round, shipped. Delimited text — CSV, TSV, any single-byte separator — and XLSX, ODS and Numbers workbooks read a batch at a time into typed columns, every cell cast through a HyperCast door and carrying its own verdict, the FFI boundary crossed once per few thousand rows instead of once per cell. The thesis is amortization: a million-row, 20-column file is 20 million scalar casts, which driven cell by cell is real crossing overhead on the cheapest FFI and catastrophic from Python or Ruby, and driven a batch at a time rounds to zero. It is one repository, one crate and one native library for both formats, because a binding that links the core in — Go, Swift, C# Native AOT — cannot take two archives that each carry HyperCast's symbols.

The receipts: every cell of a delimited file located at 1.05 GiB/s against 978 MiB/s for Rust's csv crate, the structural scan alone at 2.18 GiB/s; a 300,000-row Excel workbook read whole in 0.57–0.63 s from Rust, C#, Java, Go, Swift and Python alike — the language barely shows — and a 300,000-row Numbers document in 1.16–1.32 s, where numbers-parser, the reference Python reader, takes 68 s.

The shared foundry behind all of them: reusable CI pipelines that prove one Rust core against every language binding's real test suite, pack/publish/attest workflows that put a build-provenance attestation on every artifact, scaffolding conventions a new Hyper* repo adopts wholesale, and the build archaeology — learned once, banked, never re-learned. Each release also carries one attestation, signed at the tag, that names every shipped file, so gh attestation verify <file> --repo SkunkWerkx/<Repo> --source-ref refs/tags/vX.Y.Z --predicate-type …/release/v1 answers for a wheel, a Go archive and a gem alike, and the pipelines publish tokenless wherever a registry offers Trusted Publishing.

The lineage runs straight through this page: SequentialGuid's SQL Server byte-order permutation seeded HyperUuid's ordering transforms, and Svartálfheim's Norse.Primitives conformance suites seeded HyperCast's corpus.