C# Console App Ideas (.NET 10 / C# 14): 25+ Projects, Real GitHub Repos, 2026 Stack

Last updated April 2026 — refreshed for .NET 10 LTS, C# 14, and the current console-app tooling stack.

C# console applications are still the fastest way to learn the language and the most common shape of a real-world internal tool: think CLI for a backend team, a one-shot data-migration script, an ML.NET inference job, or a long-running worker. This guide gives you 25+ project ideas graded by skill level, the modern .NET 10 / C# 14 starter template, the libraries that actually matter in 2026 (Spectre.Console, System.CommandLine, ML.NET 5.0), and links to real GitHub repos you can fork and run today. No filler, no outdated screenshots — just the version pins, code, and decisions you need.

What changed in 2026 — read this first if your last C# console app was on .NET 6/7.NET 10 is the current LTS (released 11 Nov 2025, supported until 10 Nov 2028). .NET 8 LTS and .NET 9 STS both end of support 10 Nov 2026 — start new console projects on .NET 10. Source: Microsoft .NET support policy.C# 14 ships with .NET 10: field-backed properties (no more boilerplate _field), extension members on interfaces and statics, partial constructors and events, lambda parameter modifiers (ref, in, out, scoped) without explicit types.File-based programs: dotnet run app.cs now executes a single C# file with no .csproj, and publishes Native AOT by default — closer to scripting ergonomics. See What's new in .NET 10.Top-level statements are still the default for dotnet new console. If you prefer the classic static void Main, pass --use-program-main.Visual Studio 2026 (Windows-only) is the current VS, but JetBrains Rider is now free for non-commercial use on Windows, macOS and Linux — for the cross-platform C# crowd this matters. VS Code with the C# Dev Kit is the third mainstream option..NET Framework console apps are legacy. Don't start new console projects on .NET Framework 4.8 — the cross-platform dotnet CLI on .NET 10 is the modern path. Older Codersera advice mentioning ".NET Core or .NET Framework" no longer applies; .NET (since v5) is the unified product.

TL;DR — what to build, and on what

Setting up a modern C# console project (2026)

Forget the legacy "create a project in Visual Studio, choose .NET Framework or .NET Core" flow. The 2026 path is one CLI command:

dotnet --version           # need 10.0.x
dotnet new console -n MyApp --framework net10.0
cd MyApp
dotnet run

That generates a single Program.cs using top-level statements:

// Program.cs (default .NET 10 template)
Console.WriteLine("Hello, World!");

If you prefer the classic shape with Main for teaching or for code-review consistency, opt out:

dotnet new console -n MyApp --use-program-main

Which gives you the more recognisable layout:

namespace MyApp;

internal class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Hello, World!");
    }
}

Run, build, publish:

dotnet run                                    # iterate
dotnet build -c Release                       # binary in bin/Release/net10.0/
dotnet publish -c Release -r linux-x64 \
    --self-contained -p:PublishSingleFile=true # single-file deploy
dotnet publish -c Release -r linux-x64 \
    -p:PublishAot=true                        # Native AOT, ~3-10 MB binary, no .NET runtime needed

Native AOT in .NET 10 is much more stable than in .NET 7/8 — the trim warnings most third-party libraries used to throw are largely fixed, and the resulting binary starts in single-digit milliseconds. For a CLI tool you ship to colleagues, AOT is the right default now.

Pick an IDE — three reasonable choices

• Visual Studio 2026 (Windows only). Best for Windows + Azure work. Heavyweight; slow on huge solutions.
• JetBrains Rider (Windows, macOS, Linux). Free for non-commercial use as of late 2024. Faster solution loads than VS, better refactoring. Paid for commercial work.
• VS Code + C# Dev Kit (all platforms). Lightweight, free for everyone, works fine for console apps. The Dev Kit gives you solution explorer, test runner, and IntelliSense.

Beginner project ideas (1–3 days each)

The point of a beginner project is to feel friction once and learn the shape of it: parsing input, branching, looping, methods, error handling. Pick three from below before moving on.

1. Console calculator

Classic for a reason. The auditor flagged the previous code sample — here it is properly formatted on .NET 10 / C# 14, using a switch expression and double.TryParse:

double a = ReadNumber("First number: ");
double b = ReadNumber("Second number: ");
Console.Write("Operation [+ - * /]: ");
char op = Console.ReadKey().KeyChar;
Console.WriteLine();

double result = op switch
{
    '+' => a + b,
    '-' => a - b,
    '*' => a * b,
    '/' when b != 0 => a / b,
    '/' => double.NaN,
    _ => double.NaN,
};

Console.WriteLine(double.IsNaN(result) ? "Invalid operation." : $"Result: {result}");

static double ReadNumber(string prompt)
{
    while (true)
    {
        Console.Write(prompt);
        if (double.TryParse(Console.ReadLine(), out var n)) return n;
        Console.WriteLine("Not a number, try again.");
    }
}

2. Guess-the-number

Random number 1–100, give the user "higher" / "lower" feedback, count tries. Teaches Random.Shared.Next(), loops, and integer parsing.

3. To-do list (in-memory then JSON-backed)

Add, list, complete, delete tasks. Start in-memory; v2 persists to tasks.json with System.Text.Json (built into the runtime, no NuGet package needed).

4. FizzBuzz

Print 1–100, "Fizz" for multiples of 3, "Buzz" for multiples of 5, "FizzBuzz" for both. Trivial — but it's the canonical interview warm-up and a chance to practice modulo and string concatenation.

5. Unit converter

Length, mass, temperature, currency. The currency variant doubles as your first HTTP-API project — call exchangerate.host or a similar free FX API with HttpClient.

6–10. Other beginner picks

• Hangman — string manipulation, character matching, ASCII art. Reference implementation in the official dotnet-console-games repo.
• Rock-paper-scissors — switch on enum, simple AI is "pick uniformly".
• Tic-tac-toe — 2D array, win-condition check; minimax for the AI is a good v2.
• Mad Libs generator — string interpolation and lists of templates.
• Stopwatch / countdown timer — Stopwatch class, Console.KeyAvailable for non-blocking input.

Intermediate project ideas (4–10 days each)

1. Weather CLI

Hit the OpenWeatherMap API, parse JSON with System.Text.Json, render a 5-day forecast as a Spectre.Console table:

using Spectre.Console;
using System.Net.Http.Json;

var http = new HttpClient();
var key = Environment.GetEnvironmentVariable("OWM_KEY")
    ?? throw new InvalidOperationException("Set OWM_KEY");
var city = args.Length > 0 ? args[0] : "London";

var url = $"https://api.openweathermap.org/data/2.5/forecast?q={city}&appid={key}&units=metric";
var data = await http.GetFromJsonAsync<ForecastResponse>(url);

var table = new Table().Title($"5-day forecast for {city}");
table.AddColumn("Time");
table.AddColumn("Temp °C");
table.AddColumn("Conditions");
foreach (var slot in data!.list.Take(8))
    table.AddRow(slot.dt_txt, slot.main.temp.ToString("F1"), slot.weather[0].description);

AnsiConsole.Write(table);

record ForecastResponse(List<Slot> list);
record Slot(string dt_txt, Main main, List<Weather> weather);
record Main(double temp);
record Weather(string description);

Add Spectre.Console with: dotnet add package Spectre.Console (11.4k stars, MIT, currently maintained — see the GitHub repo).

2. Personal finance / expense tracker (SQLite)

Add an expense (date, category, amount, note). Query: total this month, breakdown by category, top 5 categories. Use Microsoft.Data.Sqlite directly or Microsoft.EntityFrameworkCore.Sqlite if you want EF Core practice. Pair with Spectre.Console BarChart for the visualisation.

3. Markdown → HTML converter

Use Markdig (the .NET Markdown parser used by Microsoft Learn itself). Read a folder of .md files, write a folder of .html, support a --watch flag with FileSystemWatcher.

4. Quiz program

Load questions from a YAML file, randomise order, score the user, persist a high-score table. Good first exercise in deserialisation with YamlDotNet.

5. File hash & duplicate-finder

Walk a directory tree, compute SHA-256 of each file with SHA256.HashData, group by hash, print duplicate clusters. Add a --delete flag (with a confirmation prompt) for v2. Teaches streams, hashing, and "be careful with destructive flags".

6. Port scanner

Async TCP-connect scan of a host across a port range, with a configurable timeout and parallelism via Parallel.ForEachAsync. Teaches Task, CancellationToken, and connection error handling. Use it only against your own hosts.

7. Discord or Slack bot (console-hosted)

Use Discord.Net. The bot itself is a console app: it logs in, subscribes to events, replies to commands. Good first taste of long-running async services.

8. Quote-of-the-day CLI tool

Calls a public API (zenquotes.io, quotable.io), caches the day's quote in ~/.config/qotd/cache.json, prints it with optional ASCII formatting. Publish as a dotnet tool so it installs with dotnet tool install -g qotd.

Advanced project ideas (2+ weeks)

1. Console e-commerce / inventory system

Models: Product, Customer, Order, OrderLine. EF Core + SQLite (or PostgreSQL if you want a heavier stack). Subcommands via System.CommandLine: shop browse, shop cart add, shop checkout. Add a discount-rule engine to practise the strategy pattern.

2. gRPC client/server pair

One console app exposes a greeter.proto service over gRPC, the other consumes it. Demonstrates contract-first APIs, HTTP/2, and streaming. Microsoft's gRPC docs cover the wiring.

3. ML.NET 5.0 image classifier

Train (or load a pretrained) image classifier with ML.NET 5.0 (released 11 Nov 2025 alongside .NET 10). Console app: pass a path to an image, print "cat 0.93 / dog 0.04 / other 0.03". The official machinelearning-samples repo has a runnable image-classification project you can adapt.

4. Worker service / scheduled job

Use the Worker template: dotnet new worker. BackgroundService + IHostedService + DI + structured logging via Serilog or the built-in Microsoft.Extensions.Logging. Container-ready. This is what most production "console apps" actually are.

5. Git log analyzer

Use LibGit2Sharp to walk a repo's history. Output: top contributors, churn-by-file, busiest day-of-week. Render with Spectre.Console BarChart and Tree. Real internal-tools shape — engineering managers love these.

6. Distributed-cache warmer

Connects to Redis (StackExchange.Redis) or a similar cache, pulls a list of keys from a config file, fires parallel HTTP requests at upstream services to repopulate them. Teaches IO-bound parallelism, retry policies (Polly), and idempotency.

7. Native-AOT-published single-file CLI

Take any of the intermediate ideas and ship it as a Native AOT binary. Goal: ./mytool is one self-contained 5–10 MB executable, starts in < 30 ms, has no .NET runtime dependency on the target machine. This is genuinely production-grade tooling.

Libraries that actually matter for console apps in 2026

How to choose your next project — a decision tree

1. Have you written 1,000 lines of C# yet? No → Start with Calculator + Guess-the-Number + To-Do List. Stop reading this guide and go build them.
2. Yes, but you've never called a public API. Build the Weather CLI or the QOTD tool. The point is to feel HTTP + JSON.
3. You've done APIs but never persisted data. Build the expense tracker with SQLite. Persistence is the next milestone.
4. You can persist and call APIs. Pick something with concurrency: port scanner, cache warmer, Discord bot. Async/await is where most C# learners stall.
5. You want a portfolio piece. Native-AOT-publish a real CLI tool, ship it as a dotnet tool on NuGet, and write a README that shows benchmarks. This actually moves the needle in interviews.
6. You want to feel "professional". Worker service + DI + structured logging + OpenTelemetry. That's the shape of 80% of paid backend C# work.

If you're a hiring manager scanning this and wondering whether your next backend hire's portfolio is real, Codersera's pre-vetted remote .NET engineers have shipped exactly these patterns into production. The interview rubric we use is roughly the same decision tree.

Performance — what to expect from a .NET 10 console app

Concrete numbers from public benchmarks and Microsoft's own .NET 10 release notes:

• Cold start (Native AOT): typical "hello world" published as Native AOT on .NET 10 starts in roughly 5–25 ms on Linux x64, vs. 80–200 ms for a normal JIT-compiled console app. The exact number depends on disk and CPU, but the order-of-magnitude gap is real and reproducible.
• Binary size (Native AOT): a minimal console app trims to roughly 3–6 MB on Linux, 8–12 MB with Spectre.Console added. Self-contained non-AOT publishes are 60–80 MB.
• Throughput: .NET 10 ships with > 1,000 perf-related changes (Microsoft's number) including AVX10.2 codegen, better stack-allocation, and improved devirtualization. Real-world: most CPU-bound console workloads see 5–15% speedups vs .NET 8 with no code changes.
• Memory: AOT binaries use noticeably less RAM at startup (no JIT, no shared CoreCLR), which matters if you're spawning many short-lived processes.

If you're benchmarking, use BenchmarkDotNet — that's the canonical .NET microbenchmark harness. Don't measure with Stopwatch in a loop; you'll be measuring the JIT.

Common pitfalls and troubleshooting

Garbled Unicode / emoji output on Windows

Windows console defaults to a legacy code page. Set:

Console.OutputEncoding = System.Text.Encoding.UTF8;

Or use Windows Terminal (default since Windows 11), which is UTF-8 native.

Native AOT publish fails with trim warnings

Reflection-heavy code (e.g. Newtonsoft.Json defaults, older DI containers) won't trim cleanly. Either switch to System.Text.Json source generators or mark the offending types with [DynamicallyAccessedMembers]. This is dramatically better in .NET 10 than it was in .NET 7, but expect a few hours of cleanup the first time.

"Cannot find Main method" with async

Top-level statements support await directly. If you're on the classic template, change static void Main to static async Task Main.

Wrong working directory at runtime

Don't read files with relative paths that assume CWD is the project folder. Use AppContext.BaseDirectory or take an explicit path argument.

Null reference from Console.ReadLine()

On .NET 10 with nullable reference types on (the default), Console.ReadLine() returns string?. Always handle the null (EOF/redirected stdin) case.

What was removed and why

The earlier version of this guide referenced tooling that's now stale or wrong. For the record:

• "Open Visual Studio, choose .NET Core or .NET Framework" — there is no choice in 2026. Pick .NET 10 for new work. .NET Framework 4.8 is feature-frozen and Windows-only; only touch it for legacy maintenance.
• The malformed namespace example — fixed in the calculator and worker examples above.
• The off-topic ML/job-listing footer — gone. If you're learning C# to get hired, build something real, ship it to GitHub, and apply (or talk to Codersera if you want to be matched with remote roles).

Real GitHub repos to learn from

Don't read about console apps — clone these and run them. All actively maintained as of 2026:

• dotnet/dotnet-console-games — 40+ classic games (Pac-Man, Wordle, Hangman, Blackjack, Tower of Hanoi) implemented as small .NET console apps. Apache-2.0. The single best read-and-fork resource for beginners.
• spectreconsole/spectre.console — the library itself plus an examples directory with runnable demos of every widget.
• dotnet/machinelearning-samples — production-shaped ML.NET tutorials including image classification, sentiment analysis, and time-series forecasting, mostly as console apps.
• microsoftgraph/dotnetcore-console-sample — calling Microsoft Graph from a .NET console app (auth, paging, throttling).
• dotnet/samples — csharp — the official Microsoft C# sample collection, organised by language version (10.0, 11.0, 12.0, 13.0, 14.0).

Related Codersera reading

• C# Project Ideas — beginner to expert for non-console (WPF, ASP.NET, Unity) ideas.
• 30 Best C# Project Ideas across all skill levels.
• ASP.NET C# Project Ideas for when you outgrow the console.
• Advanced C# Programming Project Ideas for distributed-systems and real-time work.

FAQ

Should I learn C# 14 or stick with C# 10/11/12?

Learn C# 14 features as you need them. The fundamentals (classes, generics, async/await, LINQ, records, pattern matching) haven't changed. Field-backed properties and primary constructors are quality-of-life wins; you don't need them on day 1.

Visual Studio, Rider, or VS Code?

On Windows-only with corporate license: Visual Studio 2026 Community or Professional. On any platform with personal/non-commercial use: free Rider. Lightweight or remote SSH dev: VS Code with the C# Dev Kit. None of them is wrong for console apps.

Is .NET Framework dead for console apps?

For new projects, yes — start on .NET 10. .NET Framework 4.8.x is still supported by Microsoft as part of Windows Server and gets security updates, but it's feature-frozen. The cross-platform dotnet CLI on .NET 10 is where all language and runtime improvements land.

How do I publish my console app so users don't need .NET installed?

Two options. Self-contained: dotnet publish -r linux-x64 --self-contained -p:PublishSingleFile=true. The runtime is bundled — binary is ~70 MB. Native AOT: dotnet publish -r linux-x64 -p:PublishAot=true. Compiles to native machine code — binary is 3–10 MB and starts much faster, but some libraries (heavy reflection users) won't work without tweaks.

What's the best way to parse command-line arguments?

For 1–2 flags, parse args manually. For anything with subcommands, use System.CommandLine (Microsoft's, used by the dotnet CLI itself) or Spectre.Console.Cli. Don't roll your own beyond a couple of switches.

Can I make money writing C# console apps?

Plenty of dev tooling sells as CLI binaries (database migration tools, security scanners, infrastructure utilities). More common: console apps as the entry point to a service contract — many backend "microservices" are console apps under the hood. Codersera's clients regularly hire remote .NET engineers for exactly this kind of work.

Does ChatGPT / Claude write decent C# console apps now?

For the beginner ideas listed here, yes — modern LLMs produce passable C# 14. The skills you should be developing are: spotting bad async usage, knowing which NuGet package is canonical (vs. abandoned), and trimming output for AOT. Those still take human review in 2026.

How long until I should move beyond console apps?

When the user interaction gets too rich for a TTY. Honest answer: most professional .NET work that looks like "console apps" actually stays as console apps forever — Worker Services, CLI tools, batch jobs, lambdas. The console isn't a stepping stone; it's a deployment target.

References & further reading

• What's new in .NET 10 — Microsoft Learn
• What's new in C# 14 — Microsoft Learn
• .NET and .NET Core official support policy — Microsoft
• Announcing .NET 10 — .NET Blog
• Native AOT deployment overview — Microsoft Learn
• dotnet/dotnet-console-games — 40+ runnable .NET console games (GitHub)
• spectreconsole/spectre.console — beautiful console UIs (GitHub)
• dotnet/machinelearning — ML.NET 5.0 source & release notes (GitHub)
• System.CommandLine documentation — Microsoft Learn
• dotnet/BenchmarkDotNet — canonical .NET benchmarking harness (GitHub)

Codersera matches companies with vetted remote .NET engineers — backend services, CLI tooling, ML.NET inference, the lot. If you're hiring, browse the developer pool; if you're a developer, the projects in this guide are exactly the kind of work our clients ask interview candidates to ship.