A collection of C# executables, web apps, and automation scripts — plus ready-to-copy code snippets.
C# Console App combining file organization and server utilities in one application.
View on GitHubOrganize folders by file extension automatically with a single click.
View on GitHubC# Console App for server management and utility tasks.
View on GitHubCopy and paste this command into your PowerShell terminal to download the file directly:
Invoke-WebRequest -Uri "" -OutFile ""
A custom CLI tool that provides enhanced command-line functionality and workflow optimization using node.js framework.
This is also my biggest programming project built with absolute focus and a lot of care.
Long term support, so new features will always come and bug fixes are constant
Completely re-written codebase, new architecture prepared for new updates to come
Version: Uploading Download .exeClick any card to copy the code straight to your clipboard. Filter by category or star your favourites.
Use: Displays rotating spinner (|, /, -, \).
Implementation: Runs on Task.Run() to prevent blocking. Perfect for file I/O or API calls.
Task loadingTask = Task.Run(() => {
while (isLoading) {
Console.Write($"\rLoading... {spinner[index % spinner.Length]}");
index++;
Thread.Sleep(100);
}
});
Console.ReadKey();
isLoading = false;
loadingTask.Wait();
Use: Shows growing/shrinking dots (. .. ...).
Implementation: Non-blocking animation. Ideal for UX feedback during loading states.
Task loadingTask = Task.Run(() => {
while (isLoading) {
string dots = new string('.', (dotCount % 4));
Console.Write($"\rLoading{dots} ");
dotCount++;
Thread.Sleep(500);
}
});
Console.ReadKey();
isLoading = false;
loadingTask.Wait();
Use: Visual bar filling 0-100% with percentage.
Implementation: Background thread with pacing. Great for showing task progress.
Task loadingTask = Task.Run(() => {
while (isLoading && progress < 100) {
int filled = (progress / 5);
string bar = new string('█', filled) + new string('░', 20 - filled);
Console.Write($"\rProgress: [{bar}] {progress}%");
progress++;
Thread.Sleep(100);
}
});
Console.ReadKey();
isLoading = false;
loadingTask.Wait();
Use: Wave effect with brackets moving left/right.
Implementation: Separate thread execution. Perfect for continuous operations.
Task loadingTask = Task.Run(() => {
while (isLoading) {
Console.Write($"\rLoading {wave[index % wave.Length]}");
index++;
Thread.Sleep(150);
}
});
Console.ReadKey();
isLoading = false;
loadingTask.Wait();
Use: Bouncing boxes creating wave pattern.
Implementation: Prevents main thread blocking. Great for interactive loading screens.
Task loadingTask = Task.Run(() => {
while (isLoading) {
Console.Write($"\rLoading {bounce[index % bounce.Length]}");
index++;
Thread.Sleep(120);
}
});
Console.ReadKey();
isLoading = false;
loadingTask.Wait();
Use: Circular progress indicator filling 0-100%.
Implementation: Background thread animation. Perfect for file downloads or processing.
Task loadingTask = Task.Run(() => {
while (isLoading && progress < 100) {
Console.Write($"\rProgress: {circle[progress % 4]} {progress}%");
progress++;
Thread.Sleep(50);
}
});
Console.ReadKey();
isLoading = false;
loadingTask.Wait();
Use: Dual bar chart for memory and CPU percentages.
Implementation: Real-time resource visualization. Use actual System metrics in production.
Task loadingTask = Task.Run(() => {
while (isLoading) {
int memory = rand.Next(30, 95);
int cpu = rand.Next(20, 85);
string memBar = new string('█', memory / 5) + new string('░', 20 - (memory / 5));
string cpuBar = new string('█', cpu / 5) + new string('░', 20 - (cpu / 5));
Console.Write($"\rMemory: [{memBar}] {memory}% | CPU: [{cpuBar}] {cpu}%");
Thread.Sleep(500);
}
});
Console.ReadKey();
isLoading = false;
loadingTask.Wait();
Use: Animated bar chart comparing multiple values.
Implementation: Background thread with smooth animation. Great for data presentation.
Task animTask = Task.Run(() => {
for (int frame = 0; frame <= 20; frame++) {
for (int i = 0; i < items.Length; i++) {
int filledWidth = (values[i] / 5) * frame / 20;
string bar = new string('█', filledWidth) + new string('░', 20 - filledWidth);
Console.WriteLine($"{items[i]}: [{bar}] {(values[i] * frame / 20)}%");
}
Thread.Sleep(100);
}
});
Console.ReadKey();
isAnimating = false;
animTask.Wait();
Use: Numbers incrementing from 0 to target value.
Implementation: Background thread counting. Perfect for stats dashboards and metrics.
Task animTask = Task.Run(() => {
while (isAnimating && current[3] < targets[3]) {
for (int i = 0; i < targets.Length; i++) {
if (current[i] < targets[i]) current[i]++;
}
Console.Write($"\rVisitors: {current[0]:000} | Sales: ${current[1]:000}");
Thread.Sleep(50);
}
});
Console.ReadKey();
isAnimating = false;
animTask.Wait();
Use: Arrow key navigation with Enter to select.
Implementation: Interactive CLI menu. Great for CLI applications and user selection.
for (int i = 0; i < options.Length; i++) {
if (i == selected)
Console.WriteLine($"▶ {options[i]} ◀");
else
Console.WriteLine($" {options[i]}");
}
var key = Console.ReadKey(true).Key;
if (key == ConsoleKey.UpArrow && selected > 0) selected--;
else if (key == ConsoleKey.DownArrow && selected < options.Length - 1) selected++;
else if (key == ConsoleKey.Enter) {
Console.WriteLine($"\n✓ Selected: {options[selected]}");
break;
}
Use: Visual bar showing password strength level.
Implementation: Real-time analysis on background thread. Perfect for registration forms.
Task analyzeTask = Task.Run(() => {
for (int frame = 0; frame < 30; frame++) {
int strength = CalculateStrength(password) * frame / 30;
string bar = new string('█', strength) + new string('░', 20 - strength);
string label = strength < 5 ? "Very Weak" : "Good";
Console.Write($"\rStrength: [{bar}] {label}");
Thread.Sleep(50);
}
});
analyzeTask.Wait();
Console.WriteLine("\n✓ Analysis Complete!");
Use: Pop-up message that appears and fades automatically.
Implementation: Background thread with timed fade. Perfect for user feedback.
Task toastTask = Task.Run(() => {
Console.WriteLine($"┌─ {msg} ─┐");
for (int i = 0; i < 30; i++) {
Thread.Sleep(100);
}
Console.WriteLine("└─ Fading... ─┘");
});
toastTask.Wait();
Thread.Sleep(500);
Use: Styled alert with severity levels (info, warning, error).
Implementation: Multiple alert types with icons. For displaying important messages.
Console.WriteLine("┌─────────────────────────────────┐");
Console.WriteLine("│ ℹ INFO: System check passed │");
Console.WriteLine("└─────────────────────────────────┘\n");
Console.WriteLine("┌─────────────────────────────────┐");
Console.WriteLine("│ ⚠ WARNING: Low memory detected │");
Console.WriteLine("└─────────────────────────────────┘\n");
Console.WriteLine("┌─────────────────────────────────┐");
Console.WriteLine("│ ✗ ERROR: Connection failed │");
Console.WriteLine("└─────────────────────────────────┘");
Use: Pulsing status indicators for online/offline/loading.
Implementation: Background thread with pulsing effect. For status displays.
Task animTask = Task.Run(() => {
int cycle = 0;
while (isAnimating) {
int brightness = (cycle % 20) < 10 ? cycle % 10 : 10 - (cycle % 10);
string pulse = new string('●', brightness) + new string('○', 10 - brightness);
Console.Write($"\r● Online: [{pulse}] | ● Away: [●●●●●]");
cycle++;
Thread.Sleep(100);
}
});
Console.ReadKey();
isAnimating = false;
animTask.Wait();
Use: Text appearing character by character.
Implementation: Background thread typing. Perfect for dialogues and introductions.
Task typeTask = Task.Run(() => {
string text = "Hello! This is a typing effect...";
foreach (char c in text) {
if (!isTyping) break;
Console.Write(c);
Thread.Sleep(50);
}
});
Console.ReadKey();
isTyping = false;
typeTask.Wait();
Console.WriteLine("\n✓ Complete!");
Use: Animated text glitch/distortion effect.
Implementation: Background thread with distortion. Great for error states.
Task glitchTask = Task.Run(() => {
string[] glitches = { "ǝɹɹoɹǝ ɯǝʇsʎs", "SYSTEM ERRoR", "SYSTƐɯ ERROR", original };
while (isGlitching) {
Console.Write($"\r{glitches[index % glitches.Length]} ");
index++;
Thread.Sleep(200);
}
});
Console.ReadKey();
isGlitching = false;
glitchTask.Wait();
Use: Decorative lines that animate and expand.
Implementation: Simple animation loop. Perfect for section dividers.
for (int width = 0; width <= 40; width += 2) {
Console.Write($"\r{new string('─', width)}●{new string('─', 40 - width)}");
Thread.Sleep(50);
}
Console.WriteLine("\n\n✓ Complete!");
Use: Progress through multiple stages/steps.
Implementation: Background thread with step tracking. Great for wizards and processes.
Task processTask = Task.Run(() => {
while (isProcessing && currentStep < steps.Length) {
for (int i = 0; i < steps.Length; i++) {
if (i < currentStep)
Console.WriteLine($"✓ {steps[i]}");
else if (i == currentStep)
Console.WriteLine($"► {steps[i]}...");
else
Console.WriteLine($"○ {steps[i]}");
}
currentStep++;
Thread.Sleep(1500);
}
});
Console.ReadKey();
isProcessing = false;
processTask.Wait();
Use: Placeholder animation showing loading state.
Implementation: Background thread with placeholder blocks. For UI placeholders.
Task loadTask = Task.Run(() => {
int frame = 0;
while (isLoading) {
string skeleton = frame % 2 == 0 ? "▓▓▓▓▓▓▓▓▓▓" : "░░░░░░░░░░";
Console.WriteLine($"Title: {skeleton}");
Console.WriteLine($"Content: {skeleton} {skeleton}");
Console.WriteLine($"Avatar: {skeleton}");
frame++;
Thread.Sleep(300);
}
});
Console.ReadKey();
isLoading = false;
loadTask.Wait();
Use: Fading brightness animation with shimmer.
Implementation: Background thread pulsing. For highlight and attention effects.
Task shimmerTask = Task.Run(() => {
int cycle = 0;
while (isAnimating) {
int brightness = (cycle % 20) < 10 ? cycle % 10 : 10 - (cycle % 10);
string pulse = new string('█', brightness) + new string('░', 10 - brightness);
Console.Write($"\r[{pulse}] Shimmer Effect");
cycle++;
Thread.Sleep(100);
}
});
Console.ReadKey();
isAnimating = false;
shimmerTask.Wait();
Use: Navigation path with current location highlighted.
Implementation: Arrow key navigation with Enter confirm. For file paths and nav hierarchy.
string breadcrumb = "";
for (int i = 0; i < path.Length; i++) {
if (i == current)
breadcrumb += $"[{path[i]}]";
else
breadcrumb += path[i];
if (i < path.Length - 1)
breadcrumb += " > ";
}
Console.WriteLine(breadcrumb);
var key = Console.ReadKey(true).Key;
if (key == ConsoleKey.LeftArrow && current > 0) current--;
else if (key == ConsoleKey.RightArrow && current < path.Length - 1) current++;
Use: Animated switching between multiple tabs/sections.
Implementation: Arrow keys to switch, Enter to confirm. Perfect for tabbed interfaces.
for (int i = 0; i < tabs.Length; i++) {
if (i == activeTab)
Console.Write($"┌─ {tabs[i]} ─┐ ");
else
Console.Write($" {tabs[i]} ");
}
var key = Console.ReadKey(true).Key;
if (key == ConsoleKey.LeftArrow && activeTab > 0) activeTab--;
else if (key == ConsoleKey.RightArrow && activeTab < tabs.Length - 1) activeTab++;
else if (key == ConsoleKey.Enter)
Console.WriteLine($"\n✓ Selected Tab: {tabs[activeTab]}");
Use: Menu that slides in and out with animation.
Implementation: Space to toggle, Q to quit. Perfect for responsive menus.
if (sidebarOpen) {
Console.WriteLine("┌─────────────┐ Main Content Area");
Console.WriteLine("│ ≡ Menu │ This is main content");
Console.WriteLine("│ • Home │ The sidebar slides in");
} else {
Console.WriteLine("≡ Main Content Area");
}
var key = Console.ReadKey(true).Key;
if (key == ConsoleKey.Spacebar)
sidebarOpen = !sidebarOpen;
else if (key == ConsoleKey.Q)
break;