Building in Public: Why We Launched nugx.org

Go to any new API platform, any hot developer tool, any freshly launched SDK. Scroll to the code examples. You'll see Python. You'll see TypeScript. Maybe Rust if they're feeling adventurous. Five years ago, you'd see C# right there alongside them. Ruby too. Now? Nothing.

This isn't because C# got worse. It got better--dramatically better. Minimal APIs, native AOT, top-tier performance benchmarks, a type system that would make TypeScript developers weep with envy. But somewhere along the way, the ecosystem stopped showing up. The community stopped demanding a seat at the table. And the rest of the industry quietly moved on without us.

The .NET Visibility Problem

Here's the thing about ecosystems: they're self-reinforcing. When a new developer sees Python and TypeScript examples everywhere, they learn Python and TypeScript. When they build products, they build them in Python and TypeScript. When they launch developer tools, they write docs for--you guessed it--Python and TypeScript.

Meanwhile, .NET developers are out here building enterprise systems that process millions of transactions a day, running cloud infrastructure that never goes down, writing code that is genuinely excellent--and getting zero credit for it in the broader developer zeitgeist.

The language doesn't need a glow up. The ecosystem does.

So We Built nugx.org

For years, .NET developers have relied on NuGet--and it's solid. The registry works. The CLI works. But when it comes to discovering packages, understanding dependencies, or comparing alternatives, the default experience leaves a lot on the table.

So we built nugx.org--an alternative NuGet front-end designed for how developers actually work:

Better search. Results ranked by relevance, not alphabetical order. You shouldn't have to know the exact package name to find what you need.
Popularity and usage signals. Download trends, version adoption, maintenance activity--the signals that actually help you decide between three packages that do the same thing.
Dependency graphs at a glance. Before you install a package, you should know what you're pulling in. Not after. Not buried in a CLI output nobody reads.
A cleaner, faster UI. This is 2026. Developer tools should feel like developer tools, not government portals from 2011.

It's free, it's open, and it's live right now. If you're a .NET developer, go break it and tell us what's wrong. Seriously.

Why Build This in Public

I've spent my career building software for clients behind NDAs and closed doors. That work pays the bills and I'm proud of it. But there's a problem with only building in private: nobody sees the craft. Nobody benefits from the decisions, the tradeoffs, the hard lessons.

Building in public isn't about clout. It's about accountability. When you ship something the community can see and touch and criticize, you can't hide behind vague roadmaps and polished pitch decks. The code either works or it doesn't. The experience either respects the developer or it doesn't.

nugx.org is the first public artifact of something bigger we've been building. And I want people to watch the whole thing happen--warts and all.

The Noundry Connection

nugx.org isn't just a community project. It's a real-world stress test for Noundry--our developer toolset that launches on March 4. Every component of nugx.org was built using Noundry libraries and infrastructure. The search service, the API layer, the front-end--all of it running on the same stack we're about to put in developers' hands.

This was deliberate. I don't believe in demos. I believe in production. If your tooling can't build a real product that real people use, it's not ready. nugx.org is our proof of work.

Here's what nugx.org validates:

Noundry's API scaffolding. The entire backend was stood up using our opinionated project templates. Time from zero to deployed API: under a day.
Our front-end component library. The UI isn't a one-off. It's built with the same components shipping in the Noundry toolkit.
The deployment pipeline. One push to deploy. No manual steps, no DLL-copying-to-servers nonsense.
Search and data ingestion. NuGet's public API isn't trivial to work with at scale. Our data pipeline handles the indexing, transformation, and serving without breaking a sweat.

March 4 is the launch date. It's also my mom's birthday--so there's no slipping the deadline on that one.

Giving Back to the Community That Made Me

I've been writing C# professionally for a long time. The .NET community gave me a career, a perspective on software craft, and some of the best engineers I've ever worked with. But I've watched that community get quieter while other ecosystems got louder.

The npm ecosystem has dozens of alternative front-ends, analytics tools, and community-built infrastructure. Python has an entire cottage industry of package management innovation. The .NET ecosystem? We've got nuget.org. It works. But "it works" isn't how ecosystems thrive.

nugx.org is a small bet that the .NET community deserves the same energy, the same investment in developer experience, that every other major ecosystem takes for granted. It's also a statement: C# developers build world-class software. It's time the tooling reflected that.

What's Next

nugx.org is live and evolving. Here's what's on the immediate roadmap:

Package comparison. Side-by-side views of competing packages--features, dependencies, maintenance velocity, community health.
Vulnerability surfacing. Security advisories integrated directly into package pages, not buried in a separate tool.
Community annotations. Let developers leave notes, warnings, and recommendations on packages they've actually used in production.
.NET ecosystem health dashboard. Aggregated signals on the state of the .NET package ecosystem--growth trends, maintenance rates, emerging categories.

And when Noundry launches on March 4, every tool we used to build nugx.org becomes available to you. Same stack, same libraries, same shortcuts. Build something and ship it.

The Bottom Line

C# isn't dying. It's being ignored. There's a difference--and it's a fixable one. The language is faster, more expressive, and more capable than it's ever been. What's missing isn't talent or technology. It's visibility. It's fresh thinking. It's people willing to build new things in the open and prove that this ecosystem still has something to say.

nugx.org is our small contribution to that. Go try it. Tell us what's broken, what's missing, what you wish existed. We're building this for the community, and we want the community in the room while we do it.

I write about software architecture, the .NET ecosystem, and building developer tools. If you're working on something in the .NET space and want to compare notes--or if you're curious about how Noundry can accelerate your next project--I'd love to hear from you. Get in touch.