Advanced C# Project Ideas (.NET 10 / C# 14, 2026 Edition)

Last updated April 2026 — refreshed for .NET 10 LTS, C# 14, Aspire 13, EF Core 10, Blazor's unified rendering model, and the deprecation of RNGCryptoServiceProvider.

This is a working catalog of advanced C# project ideas you can ship in 2026 — every recommendation maps to a current framework version, a real reference repo, and the language features you should reach for. The goal is portfolio depth: each project is sized to take a weekend to a few weeks, exercises a non-trivial part of the modern .NET stack, and is something a hiring manager can actually open and review.

What changed in 2026 — read this before reusing 2024 sample code:.NET 10 (LTS) shipped November 11, 2025 and is supported through November 10, 2028. .NET 8 leaves LTS in November 2026 — start new projects on .NET 10.C# 14 adds field-backed properties (the field contextual keyword), extension blocks (static extension methods plus extension properties), partial constructors and events, and lambda parameter modifiers without explicit types.RNGCryptoServiceProvider is obsolete since .NET 6 (warning SYSLIB0023) and removed from new templates. Use the static methods on System.Security.Cryptography.RandomNumberGenerator — no new, no Dispose.WPF and WinForms still ship with .NET 10 and are supported, but they are Windows-only legacy stacks. New cross-platform desktop work in 2026 is usually Avalonia 11.x or .NET MAUI; MAUI is gaining Linux + browser support via an Avalonia rendering backend (announced Nov 2025).Blazor Web App is the default web UI model: per-component render modes (Server / WASM / Auto / SSR), Hot Reload for WebAssembly, and a 76% smaller blazor.web.js in .NET 10.Aspire 13 (released Nov 2025, now polyglot — Microsoft dropped the ".NET" prefix) is the recommended way to wire up multi-service projects locally with one CLI and one dashboard.Microsoft.Extensions.AI is the standard abstraction for generative-AI features in .NET — IChatClient, IEmbeddingGenerator<,>, IImageGenerator — and lets you swap OpenAI, Azure OpenAI, Ollama, or Anthropic without rewriting your code.

TL;DR — pick a project by the skill you want to prove

If hiring a senior C# engineer for a real product is on your near-term horizon, the same project archetypes work in reverse — they're the patterns we screen for when we vet developers at Codersera's hire page.

Why project-based C# learning still works in 2026

• Hiring managers read GitHub, not certificates. A live repo with sane commits, a working CI pipeline, and a deployed demo URL is now table stakes for non-junior C# roles.
• The .NET surface area widened. A 2018 portfolio that demonstrated WinForms + ADO.NET no longer maps to what a 2026 .NET shop ships. Projects need to touch async, DI, EF Core, containers, and at least one cloud service.
• AI features are normal now. "Bolt an LLM onto an existing project" is the most common interview prompt we see in 2026. Microsoft.Extensions.AI makes it a 50-line addition.
• Performance still matters. The .NET 10 JIT added AVX10.2 support, better struct-arg codegen, and improved devirtualization — projects that benchmark a hot path with BenchmarkDotNet stand out.

Foundational projects (fundamentals with modern APIs)

1. Task management system — now a Blazor Web App

Why it's still a good first project: CRUD is small enough to ship in a weekend, and the modern stack hits async, DI, EF Core, and persistence without sprawl. The 2026 upgrade is to skip WinForms / WPF and build it as a Blazor Web App so the same code runs on the server and (optionally) the client.

Stack:

• .NET 10, Blazor Web App template (dotnet new blazor --interactivity Auto)
• EF Core 10 with SQLite for local dev, Postgres for deploy
• ASP.NET Core Identity for auth, or external OIDC
• Render mode: InteractiveAuto per component (server-render the heavy list, WASM-render the editor)

Stretch features that turn this into an interview-ready project:

• Tag-based filtering with full-text search via Postgres tsvector.
• Drag-to-reorder using @onpointer* events instead of a JS interop hack.
• Realtime sync across browser tabs via a tiny SignalR hub.
• Persistent Blazor state with the new [PersistentState] attribute (.NET 10) so a circuit reconnect restores the user's draft task.

2. Cryptographically secure password generator and vault

Why this changed: The classic version used RNGCryptoServiceProvider. That type was marked obsolete in .NET 6 (warning SYSLIB0023) and is the most common stale snippet floating around the web. Use RandomNumberGenerator's static methods, which delegate to the OS CNG/CSPRNG implementation directly — no allocation, no using block needed.

Modern reference implementation:

using System.Security.Cryptography;

public static class PasswordGenerator
{
    private const string Alphabet =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*";

    public static string Generate(int length)
    {
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(length);

        Span<byte> bytes = stackalloc byte[length];
        RandomNumberGenerator.Fill(bytes); // CSPRNG, no allocation

        Span<char> chars = stackalloc char[length];
        for (int i = 0; i < length; i++)
        {
            // Modulo bias is acceptable for >=64-byte alphabets;
            // use RandomNumberGenerator.GetInt32(0, Alphabet.Length) for unbiased.
            chars[i] = Alphabet[bytes[i] % Alphabet.Length];
        }
        return new string(chars);
    }
}

Turn it into a vault: persist entries encrypted with AES-GCM (AesGcm class), derive the key from a passphrase with Argon2id (the Konscious.Security.Cryptography.Argon2 NuGet — PBKDF2 is still acceptable if you want zero dependencies via Rfc2898DeriveBytes with at least 600,000 iterations per OWASP 2023 guidance). Ship it as a CLI built with System.CommandLine.

3. Personal-finance CLI with source generation

Build a CLI that ingests CSV bank statements, categorises transactions, and exports a monthly report. The modern wrinkle: use the System.Text.Json source generator ([JsonSerializable]) so the binary is AOT-compatible. Compile with dotnet publish -p:PublishAot=true and you'll get a single <15 MB native binary that starts in single-digit milliseconds — a meaningful demo of the .NET 10 NativeAOT story.

Intermediate projects (real architecture)

4. Library management with Clean Architecture

The same domain as the original article but with a 2026 backbone:

• Solution layout: Domain, Application, Infrastructure, Web (the Jason Taylor Clean Architecture template is still a fine starting point).
• EF Core 10 with the new LeftJoin / RightJoin LINQ operators — they translate directly to SQL LEFT JOIN / RIGHT JOIN instead of the awkward GroupJoin + SelectMany dance.
• Bulk operations via ExecuteUpdateAsync, which now accepts a plain Action<SetPropertyCalls<T>> in EF Core 10 instead of an expression tree.
• Background jobs (overdue notices, fine recalculation) on IHostedService or Hangfire.

5. Weather + quote aggregator with resilient HTTP

A small ASP.NET Core service that fans out to multiple upstream APIs (OpenWeather, FCS API, Yahoo Finance) and returns a unified response. Wire it up with:

• IHttpClientFactory + Microsoft.Extensions.Http.Resilience (the modern replacement for raw Polly DI) for retries, timeouts, circuit breakers.
• HybridCache (.NET 9+) for the L1/L2 cache pattern with one API.
• OpenAPI generation via the built-in Microsoft.AspNetCore.OpenApi package (replaces Swashbuckle for many scenarios in .NET 9/10).

6. Collaborative whiteboard with SignalR

Multi-user canvas: cursors, shapes, text. Demonstrates real-time fan-out, conflict resolution, and presence. Use SignalR's MessagePack hub protocol for ~30% smaller payloads versus JSON. For more than one server instance, plug the Redis backplane (Microsoft.AspNetCore.SignalR.StackExchangeRedis) — that's the single most-asked production SignalR question on the .NET subreddit and it's worth being able to answer it from muscle memory.

Advanced projects (distributed and cloud-native)

7. Clone (or fork) of dotnet/eShop

The Microsoft dotnet/eShop repo is the canonical reference for modern .NET microservices. The main branch tracks .NET 9 today and is being moved to .NET 10; the release/8.0 branch is preserved if you want the older Aspire 1.x layout for comparison. It demonstrates:

• Aspire AppHost as the orchestrator (one F5 brings up Postgres, Redis, RabbitMQ, OpenTelemetry collector, the dashboard, and every service).
• Domain-driven design across catalogue, basket, ordering, identity, and webhooks services.
• Eventing via integration events on RabbitMQ, with the option to swap in Azure Service Bus.
• Blazor + .NET MAUI clients sharing the same backend.

Strong portfolio variant: add a new service (e.g. a recommendations service backed by an embedding model + Qdrant) and document the design decision in the README. Forking is fine; copy-pasting the README is not.

8. RAG document Q&A bot with Microsoft.Extensions.AI

Ingest a folder of PDFs / Markdown, chunk and embed them, store vectors, and answer questions over chat. The 2026 stack is genuinely simple:

• IChatClient + IEmbeddingGenerator<string, Embedding<float>> from Microsoft.Extensions.AI. Swap providers via DI: OpenAI, Azure OpenAI, Anthropic via the community connector, or local Ollama.
• Vector store: Qdrant (self-hosted, open-source) or Azure AI Search. EF Core 10 also has GA-grade vector similarity support on Cosmos DB if you prefer to keep one database.
• Streaming responses to the browser via SignalR or Server-Sent Events.
• Tool / function calling: register a couple of AIFunctions (e.g. "search the knowledge base", "schedule a call") so the model can take actions, not just answer.

9. Real-time trading or IoT dashboard

Stream live data from a public source (Coinbase Pro WebSocket for crypto, MQTT broker for IoT, or a simulated sensor feed), aggregate it server-side, and render with Blazor + a charting library (ApexCharts, Chart.js, or the open-source BlazorBootstrap charts). Add anomaly detection with ML.NET's time-series prediction or a small ONNX model. For instrumentation, expose OpenTelemetry traces and pull them into the Aspire 13 dashboard locally — Aspire 13 added a Model Context Protocol server so AI assistants like GitHub Copilot or Claude Code can query live traces directly during debugging.

10. Cross-platform desktop with Avalonia 11 or .NET MAUI

Pick one of these for desktop / mobile work in 2026:

Project idea that exercises the framework: a Markdown-first journaling app with local-first SQLite storage, encrypted-at-rest entries, full-text search, optional iCloud / Google Drive sync, and a calendar-heatmap overview. It's small enough to finish, but every screen tests a different control category.

Performance projects (where C# actually shines)

11. Custom parser with System.IO.Pipelines

Write a streaming JSON, CSV, or HTTP/2 frame parser using PipeReader, SequenceReader<byte>, and Span<T>. Benchmark against System.Text.Json using BenchmarkDotNet. You won't beat it — but the gap is the lesson, and the README writeup is exactly what senior interviewers want to see. The .NET 10 JIT improved struct-argument codegen and added AVX10.2 paths, so re-running last year's benchmarks is itself a worthwhile exercise.

12. Source generator that eliminates boilerplate

Pick a real annoyance — auto-mapping DTOs, generating INotifyPropertyChanged, hashing config types into a fast lookup — and write a Roslyn incremental source generator. IIncrementalGenerator is the modern API; analyzers should be incremental, cancellable, and avoid SyntaxNode caching to keep the IDE responsive.

13. Game or physics simulation in Unity 6 or Godot 4

Unity 6.3 LTS (December 2025) is the latest LTS line and is supported through December 2027. Godot 4 has shipped solid C# bindings via .NET 8/9 and is a credible choice for indie 2D work. A 2D roguelike, a top-down shooter, or a soft-body physics demo all give you something to talk about that isn't a TODO list.

How to choose: a decision tree

1. Are you trying to land a backend / web role? Build #4 (Clean Architecture library), #6 (SignalR whiteboard) or #7 (eShop fork). Deploy to Azure App Service / Container Apps or AWS ECS and put the URL in your README.
2. Are you targeting a mobile / desktop role? Build #10 (cross-platform journal). Ship to TestFlight / Play Internal Testing — recruiters love the "hands-on shipped" signal.
3. Do you want to break into AI engineering? Build #8 (RAG bot) and write a careful blog post about your chunking strategy and eval methodology.
4. Are you interviewing for a senior / staff role? Build #11 or #12. Performance and tooling work is the strongest "I understand the runtime" signal you can show.
5. Do you want to work in games? Build #13. Even a rough game on itch.io beats another web CRUD app.

Performance and platform numbers (April 2026)

• .NET 10 LTS: released 11 Nov 2025, supported through 10 Nov 2028 (3-year LTS).
• .NET 8 LTS: ends support 10 Nov 2026 — migrate before then.
• Blazor WASM startup: blazor.web.js dropped from ~183 KB to ~43 KB in .NET 10 (a 76% reduction), reducing first-paint cost on slow connections.
• Avalonia vs MAUI rendering throughput: Iron Software's hands-on comparison reported Avalonia hitting over 1.8M LOLs/sec on macOS versus 212 for MAUI in the same benchmark (animation-heavy workload). MAUI wins on virtualised lists thanks to native virtualization.
• Unity 6.3 LTS: shipped Dec 2025, supported until Dec 2027 (Enterprise / Industry tiers get an extra year).
• Aspire 13.2: released April 2026, adding a TypeScript AppHost preview, telemetry export/import, a telemetry HTTP API, and an MCP server for AI-agent introspection of running services.

Common pitfalls and troubleshooting

• Using RNGCryptoServiceProvider from a 2018 Stack Overflow answer. Compiler warning SYSLIB0023. Switch to RandomNumberGenerator.Fill or RandomNumberGenerator.GetBytes.
• Defaulting to WinForms / WPF for a "modern" portfolio. They still ship and still work, but new code in 2026 should default to Blazor for web, Avalonia or MAUI for native. Keep WPF for an internal-tools project where it's actually warranted.
• Skipping Aspire because "I don't need orchestration." Aspire is also useful for single-service projects: it gives you a free OpenTelemetry dashboard, parameter management, and one-line container resources (Postgres, Redis, RabbitMQ).
• Using HttpClient as new HttpClient() in a loop. Use IHttpClientFactory; otherwise you'll exhaust sockets. This is a single-most-asked-on-r/dotnet bug.
• Async over sync — .Result / .Wait(). Deadlocks ASP.NET Core requests under load. Make the call site async all the way up.
• Accidental N+1 in EF Core. Enable LogLevel.Information for Microsoft.EntityFrameworkCore.Database.Command, watch the actual SQL, and add .Include() / projections. EF Core 10's improved query translation reduces some cases but not all.
• Not pinning the SDK. Add a global.json to every repo so CI builds match local.

What was removed and why

• RNGCryptoServiceProvider. Obsolete since .NET 6, retained only for compat. Wraps the same OS CSPRNG that RandomNumberGenerator exposes more cleanly. Microsoft Learn marks it obsolete.
• "Use WinForms / WPF for the GUI" as a default recommendation. Both are supported but Windows-only. New projects should pick a cross-platform stack unless there's a Windows-only constraint.
• Blazor Server vs Blazor WebAssembly as a binary choice. The Blazor Web App template now lets you mix render modes per component (InteractiveServer / InteractiveWebAssembly / InteractiveAuto / static SSR). Don't pick "Server or WASM" up-front — start with the unified template.
• Manual HttpClient retry loops. Use Microsoft.Extensions.Http.Resilience instead of hand-rolling Polly registrations. The package was promoted to GA in .NET 8 and is the supported pattern in .NET 10.
• Newtonsoft.Json by default. Still the right choice for some legacy compat scenarios, but System.Text.Json + the source generator is the AOT-friendly default.

Frequently asked questions

Is C# still relevant in 2026?

Yes — TIOBE, RedMonk, and IEEE Spectrum all still place C# in the top 5–8 languages globally, and Stack Overflow's 2024 / 2025 surveys put .NET in the top tier of "loved" frameworks. It's the dominant stack for enterprise web in finance, healthcare, and government, plus Unity for a large slice of indie game development. If you can ship a polished .NET project, you're employable.

.NET 8 or .NET 10 for a new project?

.NET 10. .NET 8 is in LTS only until Nov 2026 — you'd be migrating within months. .NET 10 LTS runs until Nov 2028. The only reason to start on .NET 8 is if your hosting provider or third-party dependency hasn't certified .NET 10 yet.

Blazor or React for the frontend?

For an all-.NET shop, Blazor is the path of least resistance and the .NET 10 unified rendering model fixed most of the historic "is it Server or WASM?" friction. For a polyglot team or a project where the frontend must reuse a JS-ecosystem component library, React + an ASP.NET Core minimal API backend is still the more pragmatic choice. Either is hireable.

How do I add AI features to my project without locking into one vendor?

Take a dependency on Microsoft.Extensions.AI's abstractions (IChatClient, IEmbeddingGenerator) rather than the OpenAI or Anthropic SDKs directly. Then bind the concrete implementation in Program.cs. Swapping providers becomes a one-line DI change, and you can run integration tests against a stub or a local Ollama model.

Should I use MAUI or Avalonia?

If iOS + Android are your primary targets, MAUI. If Windows + macOS + Linux desktop is the priority, Avalonia. The MAUI-on-Avalonia partnership announced in November 2025 is making the choice less binary — within a year or two, MAUI on Linux and in the browser will be a real option, but right now Avalonia is more proven there.

How many projects do I need on GitHub for a C# job?

One genuinely deep project beats five shallow ones. Pick one from this list, take it from skeleton to deployed-and-monitored, and write a thoughtful README. Recruiters spend <90 seconds on a profile; they're looking for "did this person ship something real" signal. If you're recruiting in the other direction — bringing on developers who've already shipped this kind of work — that's exactly the bar we vet against on the Codersera engineer-hiring side.

My target employer is a Windows-only WPF shop. Should I still build Blazor projects?

Build one WPF project (or a WinUI 3 / WinForms project on .NET 10) so you can talk fluently about XAML data-binding and the dispatcher model — and then build one modern Blazor or ASP.NET Core project. The combination shows you can maintain their existing code and ship the next thing they're going to build.

Going further

If C# is the primary stack you're building a career on, two adjacent reads are useful next steps: our own breakdown of C# program ideas for shorter exercises, and the C# console app ideas guide for command-line-first projects. Both pair well with the longer-form projects above.

References & further reading

• Announcing .NET 10 — .NET Blog (Microsoft, Nov 2025)
• What's new in .NET 10 — Microsoft Learn
• What's new in EF Core 10 — Microsoft Learn
• RNGCryptoServiceProvider (obsolete) — Microsoft Learn
• Microsoft.Extensions.AI libraries — Microsoft Learn
• dotnet/eShop reference application — GitHub
• .NET 10 release notes — dotnet/core on GitHub
• .NET Aspire 9.1 dashboard features — .NET Blog
• .NET Aspire 13.2 release coverage — InfoQ (April 2026)
• .NET MAUI is coming to Linux and the browser, powered by Avalonia (Nov 2025)
• Unity 6 LTS support and release schedule — Unity
• r/dotnet — community discussion on tooling, releases, and project patterns