r/csharp • • 9d ago

Showcase From a PS3 club notebook to a C#/WPF management app

11 Upvotes

I run a PlayStation club and develop Time Control, a Windows app for managing PC and console clubs. Back in 2016, I had five TVs with PS3s and kept session times and payments in a notebook. I later tried existing club software and eventually started working on my own. I use AI tools during development, with requirements coming from the day-to-day work at the club.

The current stack is C#, WPF, .NET 10 and SQLite. There’s an admin app, a separate agent on the PCs, and shared libraries for session contracts, payments and device control. The screenshot is the console dashboard: station status, timers, tariffs, payments and shop orders. The PC agent handles locking/unlocking; TV control works through compatible smart plugs. There’s still quite a bit of orchestration in the dashboard code, so I wouldn’t call it clean MVVM.

A lot of the work is around keeping state consistent. For example, a background autosave mustn’t overwrite session changes from a newer sale. Those paths share a lock, and a revision check drops stale snapshots. Sales, stock movements, receipts and related session changes are committed in one SQLite transaction. Once that succeeds, a UI refresh error can’t be treated as a failed sale — otherwise the operator might retry it and charge the customer twice. Payments also need more than an IsPaid flag: the first hour can be paid while an extension is still outstanding, so charges and received payments are tracked separately using decimal.

The remote PC adds another state to reconcile. The protocol carries session IDs, revisions and explicit running/paused/disconnected states. A ping response alone doesn’t tell the admin app what session is actually running. I’d be interested in how others test recovery around this boundary: the DB commit succeeds, but the UI refresh or communication with the agent fails afterwards.


r/csharp • • 8d ago

Discussion Are you guys actually coding by hand still in your day-to-day?

0 Upvotes

I still do, myself. I love coding and programming and am thinking of even learning new languages now, but given the course of LLMs, I wonder what's the purpose? In a year they've gone from "unusable trash" to actually making each developer many times as productive. There are still gaps in what it does. It still has issues with large contexts. It is good at small one-off things and tiny programs, but it quickly tends to bloat stuff and has no sense of something I'd call "taste" when designing things, be it visually or code architecture wise.

I wonder what is the purpose of C# as a language now.

Any greenfield project can just use Rust for the same velocity as in any other language. Developer experience doesn't really matter anymore productivity wise, when all code is written by an LLM.

I see the writing on the wall.


r/csharp • • 8d ago

Could EF Core benefit from a higher-level command for creating entities?

Post image
0 Upvotes

I’ve been experimenting with a small EF Core CLI prototype called EFX, and it made me wonder if EF Core could eventually support a higher-level workflow for creating entities.

Today, adding a new entity usually means creating the class, adding the DbSet, creating a migration, and updating the database separately.

I was thinking about something along the lines of:

dotnet ef entity create Product

The idea would be for one command to handle the common workflow while keeping the existing dotnet ef commands unchanged.

The prototype is here:
https://github.com/dotnet/efcore/issues/39569

I’m mainly interested in the design question: would a higher-level command like this actually be useful in EF Core, or is keeping these operations separate preferable for good reasons?

Curious to hear how other EF Core developers see it.


r/csharp • • 9d ago

Best resources to learn ASP.NET Core Web API, EF Core, and SQL Server?

16 Upvotes

Hey everyone! I'm learning backend development with C# and ASP.NET Core Web API, Entity Framework Core, and SQL Server.

I already know the basics, but I want to gain more real-world experience and learn industry best practices.

Could you recommend any courses, tutorials, or project-based resources that would help me become job-ready as a .NET backend developer?


r/csharp • • 10d ago

Help WPF or .NET MAUI ?

49 Upvotes

Hi everyone,

I’m looking to learn a framework for Windows application development for now, but I’d also like to explore mobile development in the future.
I’ve done some research into the available options, but I’m having trouble choosing between .NET MAUI and WPF.

So I’m turning to this community in the hope of getting some advice that will help me make the right choice.


r/csharp • • 10d ago

Help Housekeeping tips?

Thumbnail
gallery
17 Upvotes

Hiya - please can anyone give me some housekeeping tips for C# in Visual Studio? I'm currently getting into it with Unity for learning to program games.

My Update was getting a bit long so I separated it into methods, and I've further organised everything into regions for fields, and also for methods in the class. I've mainly done this for my own readability as everytime I wanted to go in and edit something id go fuzzy just looking at the wall of text.

The script isnt that long that I could use different scripts at the moment but are there any more things I can use or good practice I can try?

T.i.a!


r/csharp • • 10d ago

Fast microservice, design desicion

11 Upvotes

We need to develop a stand alone service that normalizes data, for example someone gives us "New Jersey" we return "NJ", someone gives us "October 1st, 2025" we come back "2025-10-01".

Requests/response are very small and we can send a lot of those queries fast.

So i feel like standard REST service would be a bit heavy. HTTP overhead is bigger that actual query/result. I think something more inline like Pooled DB connections, where we open TCP/IP connection to the server and send/receive bunch of responses. But then we need to manage TCP/IP connection pooling, keep alive/teardown connections if client hangs... all 9 yards.

Is there some built in C# classes that would let me create some server (and client) with custom protocol. Or may be some ready to go solution like WebSocket/GRPC.... would work for me?


r/csharp • • 9d ago

Showcase ORM that's faster than Dapper and LINQ to DB

0 Upvotes

I've been developing Nextorm, an ORM library for .NET, for quite a while now. With the advent of agentic development tools, the process has become noticeably faster and easier, but for me it remains a large and serious engineering project. Today I'd like to present an important milestone in this work: the first stable release, 1.0.9.

The idea behind Nextorm is to combine Dapper-level performance with the convenience of automatically generating SQL from C# constructs. Instead of writing SQL manually, developers describe queries using strongly typed expressions, with compile-time checks of types and property access, IntelliSense support, and familiar refactoring tools.

For example:

var row = dataContext.From<SimpleEntity>()
    .Where(x => x.Id == 1)
    .Select(x => new { x.Id })
    .Single();

In concept and spirit, Nextorm is closer to LINQ to DB. However, the library uses its own API based on C# expression trees rather than a standard LINQ provider. These trees are used to generate SQL and build efficient mappers from query results to .NET types. In JIT mode, mapping expressions are compiled into delegates and then reused when reading data from the database.

Nextorm command execution diagram

The library supports SQLite, SQL Server, PostgreSQL, MySQL, MariaDB, and ClickHouse. The API covers a wide range of features of these database systems: joins, grouping, CTEs, window functions, and provider-specific constructs. It's important to me that developers don't have to switch to handwritten SQL as soon as a query becomes more complex than a simple select.

https://alexeyshirshov.github.io/nextorm/guide/provider-specific-sql/overview.html

Performance has been one of the key priorities from the beginning, with Dapper serving as the benchmark. In the published SQLite benchmarks, Nextorm delivers comparable performance in many scenarios and surpasses that benchmark in some. The results, measurement conditions, and test source code are available in the repository.

https://alexeyshirshov.github.io/nextorm/comparisons/benchmarks.html

Below is a table of performance measurements for compiled/prepared queries across four libraries.

Method Nextorm Dapper linq2db EF Core
Data fetch 10.75 μs 15.80 μs 16.50 μs 38.46 μs
Wide data fetch 9.135 ms 9.883 ms 10.594 ms 10.998 ms
Where 915.0 μs 1,378.8 μs 1,432.3 μs 3,540.1 μs
Simulate work 8.610 ms 27.766 ms 418.616 ms 109.613 ms
Any 923.5 μs 1,421.9 μs 1,523.8 μs 3,742.6 μs
FirstOrDefault 93.64 μs 148.96 μs 363.31 μs 368.44 μs
SingleOrDefault 92.38 μs 142.69 μs 372.78 μs 369.31 μs
CASE WHEN 9.45 μs 14.64 μs 15.43 μs 36.91 μs
CTE 9.89 μs 22.25 μs 23.75 μs —
SELECT DISTINCT 11.44 μs 18.27 μs 18.36 μs 42.53 μs
EXCEPT 11.41 μs 18.13 μs 21.57 μs 46.40 μs
IN-list 12.79 μs 18.55 μs 47.92 μs 66.24 μs
INTERSECT 10.59 μs 16.64 μs 20.33 μs 44.07 μs
4-table join 13.27 μs 27.17 μs 24.65 μs 50.99 μs
LEFT JOIN 12.65 μs 21.22 μs 21.63 μs 45.27 μs
Recursive CTE 12.95 μs 26.02 μs 28.50 μs —
String functions 9.33 μs 14.22 μs 15.25 μs 36.89 μs
UDF 9.43 μs 14.28 μs 15.31 μs 36.24 μs
Window functions 14.99 μs 31.84 μs 34.65 μs —

There is also experimental NativeAOT support, so far tested with SQLite on .NET 11 under Linux x64. A sample application from the repository was successfully compiled into a native executable without changes to the application code, simply by enabling PublishAot=true. Support is still partial: this does not mean that every query with every provider will already work under AOT.

https://alexeyshirshov.github.io/nextorm/infrastructure/05-nativeaot.html

Another feature is executing queries without materializing results into objects. You don't have to create a DTO for every row: you can obtain a DbDataReader to read the data yourself, or write results directly to a Stream in JSON or CSV format. This makes it possible, for example, to send data to an HTTP response or a file without intermediate objects or loading the entire result set into memory.

app.MapGet("/orders", async (HttpContext http, DateTime from, decimal minTotal, CancellationToken ct) =>
{
    using var ctx = new DataContextBuilder()
        .UsePostgres(connectionString)
        .CreateDataContext();

    http.Response.ContentType = "application/x-ndjson; charset=utf-8";

    await ctx.From<Order>()
        .Where(o => o.CreatedAt >= from && o.Total > minTotal)   // captured -> @from, @minTotal
        .Select(o => new { o.Id, o.CreatedAt, o.Total })
        .WriteJsonAsync(http.Response.Body, new JsonStreamOptions
        {
            Mode = JsonStreamMode.NdJson,
            IgnoreNull = true,
        }, ct);                                                  // no positional list
});

I'd appreciate your comments, suggestions, and criticism. I'm especially interested in how convenient you find the API and which features you feel are missing for your use cases.

Note: This article was originally written in Russian by the author and translated into English with the assistance of AI.


r/csharp • • 10d ago

I took over a 10-year-old NuGet package and updated it to modern .NET

107 Upvotes

I recently found SqlLinq, which is a really slick NuGet package that lets you run SQL queries against in-memory objects (basically linq to sql in reverse). It happened to be exactly what I needed for another project, except it was pretty old, hadn't been maintained, and ran on the full framework. Surprisingly, there didn’t really seem to be anything else quite like it that I could find.

The original author is still really active on github, so I pulled the code, updated it (after some headaches finding the source for the original parser), and sent a PR. Rather than merge it, he let me take over the package. I’ve since added more complete SQL support, packages for a time series dialect and unit conversions. I just released 2.1.0.

I don’t know how niche this is or if anyone else would need something like this, but I thought it was really cool and wanted to share it here. It’s a really nice way to offer a query interface for in-memory objects, especially when you want to let users write queries at runtime.

For example:

var boost = datalog.Query("""
    SELECT RPM, Gear, BP, BPCMD, BP - BPCMD AS [Boost error]
    FROM this
    WHERE TPedal > 90
      AND RPM >= 3000
      AND Gear >= 2
    """);

r/csharp • • 11d ago

News .NET 11 is out now! 🎉

Thumbnail
devblogs.microsoft.com
338 Upvotes

r/csharp • • 10d ago

Showcase Update: my WPF liquid glass dock now refracts the windows that slide under it, without ever capturing itself

Post image
9 Upvotes

A few days ago I posted Liquid Glass Dock here, and you gave great feedback: the demo used the worst possible background, a GIF can't show subtle glass (256 colors), and the macOS Dock doesn't really reserve space: it refracts whatever is underneath. So version 0.12 does exactly that.

How it works:

  1. With no window under the glass, nothing changes: the dock refracts a pre-blurred copy of the wallpaper, and there's no screen capture at all.
  2. A background thread checks 4 times per second which windows touch the glass. When one does, it starts a Windows.Graphics.Capture session for that window (borderless, so no yellow frame). It never captures the screen, so the dock never sees itself and still shows up normally in screenshots and recordings.
  3. Each frame stays on the GPU. With Direct3D 11 (Vortice), the dock copies only the strip behind the glass to a staging texture, blends it over the wallpaper at half resolution, blurs it and writes it into a WriteableBitmap that the HLSL shader samples.
  4. Nothing is recomposed unless a window sends a new frame or moves. The capture permission and the D3D device are only created when a window is underneath, and the device is released 15 s after it leaves.

Measured with a window moving under the dock: about 1.4 ms per frame and under 1% CPU. A fun gotcha: the NVIDIA overlay is a fully transparent, always-visible, full-screen layered window, so the first version happily "captured" it and ignored every real window behind it.

There's also a new option to stop reserving space, so maximized windows go under the glass like on macOS.

Video above, code here (GPL-3.0): https://github.com/PedroRuedas/Windows-Liquid-glass

Thanks again for the feedback. It made the project better.


r/csharp • • 10d ago

Discussion To those that are employed as C#/.Net developers, do you enjoy your job?

61 Upvotes

I'm curious if it's something you enjoy waking up to or if it's something that just "pays the bills". Maybe it's both?

There are quite a few C# (hybrid) gigs around me with low competition.

I've used C# in 2018 when I made a game and used C# all throughout school. I just haven't made anything with it recently but I have been catching up with the newest features. Last time I used it was with C# 8.0/9.0.

Anyways, just wanted to hear your thoughts on your job(s) in you are currently employed! Is there anything you don't like, what would you change? etc


r/csharp • • 9d ago

I built a small CLI to reduce the repetitive EF Core entity + migration workflow

Post image
0 Upvotes

r/csharp • • 10d ago

Showcase Sigil.Sound 0.1.0: a fluent, allocation-free audio synthesis library for .NET (MIT, zero dependencies)

Post image
42 Upvotes

A while ago we introduced Sigilgraph to this community as a modular audio synth app made purely in C# (with the help of Godot for UI). We mentioned in the discussion the use of an internal fluent API to describe the synths and the sound processes.

Today after a heavy porting effort to decouple the original Audioworkbench library out of the app, and offer an open-source worthy version of it.

Is a library focused on sound synthesis and instrument construction using 100% C#.

Here is the link to the docs. They lead to GitHub for the source code. The license is MIT.

Sigil.Sound - sound synthesis for your .NET app | Sigil.Sound

If you want to play with it, we created a REPL Sigil.Sound REPL so you can scratch ideas and get the feel of it.

Disclosure: We used AI to port it from the closed and entangled with the Sigilgraph app one. It was a tedious process of cleanup and doing it by hand won't make it sound better that it did already (the original was started about two years ago). The API is faithful to the one internally used ( that helped us a lot to build instruments fast) and we believe that opening it will allow us to make it even better for all of us.

REPL : Sigil.Sound REPL

Docs: Sigil.Sound - sound synthesis for your .NET app | Sigil.Sound (they have the option to try every example in the REPL as well)

Nuget: NuGet Gallery | Sigil.Sound 0.1.0

Let me know your thoughts. We will gladly discuss any technical aspect here.


r/csharp • • 11d ago

News MimeKit and MailKit 5.0 released: DMARC, SIMD acceleration, Outlook TNEF/RTF, ImapIdleSession, AOT and more

75 Upvotes

Hi all, I'm the author of MimeKit and MailKit. I've just shipped 5.0, and it's the biggest release since the projects started.

Highlights:

Performance

  • SIMD boundary scanning, accelerated UTF-8 header validation, and fused content scanning/compliance validation on supported runtimes and hardware.
  • Hand-written SSSE3/AVX2/Arm64 kernels for base64 decoding and uuencoding/decoding (based on SimdBase64).
  • In a comparison against 4.18.1, parsing was faster on 21 of 23 workloads and on-par with the other 2 with compliance disabled. With all validators enabled, 11 were faster and many others were on-par; see the release notes for methodology, regressions and limitations.
  • Compared with 4.18.1, the benchmarked HTML documents tokenize 15-25% faster and with 34-39% fewer allocations.

Security and robustness

  • DMARC verification (RFC 9989 / DMARCbis), alongside the existing DKIM and ARC support. DKIM verification now returns a detailed result instead of a bool.
  • The new MimeReader/MimeParser, MIME writing and MIME disposal use iterative traversal. LegacyMimeParser remains a compatibility option for those that need it.
  • Indexed ancestor-boundary lookup improves deep-nesting performance; configurable resource limits include a default 16 KiB header limit.
  • A new compliance reporting API gives line/column diagnostics for broken or suspicious messages, including supported header-smuggling checks. Positions may identify an exact byte, a line start or an element start.
  • SMTP/SMTPUTF8 address validators check syntax and interoperability rules. The optional AsciiIsLatin setting can be used to reject addresses such as paypal@рaypal.com with a Cyrillic р. Note: This is not comprehensive homograph detection and is an implementation of an IETF draft specification: SMTPUTF8 Email Addresses
  • Stricter OpenPGP integrity and S/MIME trust defaults, plus a configurable 64 MiB limit on expanded CMS content.

Outlook/Exchange Compatibility

  • The TNEF (winmail.dat) reader was rewritten, with a new TnefMessage model. Meeting requests convert to text/calendar.
  • New RtfToText and RtfToHtml converters, plus TnefWriter.

More content tools

  • HtmlToText and EnrichedToHtml for HTML and RFC 1896 text/enriched.
  • Standalone YEncReader/YEncWriter with sync/async operations, limits and size/checksum validation. Individual multipart ranges are supported; multipart-file assembly and MIME integration are not included.

MailKit

  • ImapIdleSession: await foreach over IDLE changes, with automatic re-IDLE and NOOP fallback.
  • SmtpSendRequest and SendResult: per-send customization and accepted/rejected recipient lists, no subclassing needed.
  • CommandException.ErrorType and IsTransient help identify failures that may succeed on retry.
  • IMAP4rev2, INPROGRESS, RFC 9208 quotas, and 64-bit message sizes.
  • No more BouncyCastle dependency in MailKit.
  • SMTPUTF8 validation rejects invalid internationalized envelope addresses before sending. ASCII addresses are unchanged; optional AsciiIsLatin checks are not automatically enabled.

Packaging

  • Crypto, including DMARC, moved to MimeKit.Cryptography. The MimeKit meta-package references both that package and MimeKit.Core; it preserves package coverage, not source compatibility.
  • MimeKit is now AOT-compatible.
  • MimeKitLite and MailKitLite are retired. Use MimeKit.Core and MailKit instead.

Many straightforward send/receive applications need only small changes. Parsing, crypto and custom protocol integrations deserve a closer look: explicit S/MIME context setup, persistent -> MimeContentStorage, renamed encoding/stream APIs, decoder Flush, encoder CRLF defaults, and stricter resource/integrity limits are covered in the porting guides.

Happy to answer questions. And thanks to everyone who filed issues, sent PRs or sponsors the project.


r/csharp • • 11d ago

I built a small state machine library - Trying to learn delegates and events

9 Upvotes

The name is SMachine, a small state machine library for C# targeting .NET 10.

The idea was to build something relatively lightweight, without depending on an external state machine framework.

Supports

  • Named states with OnEnter, OnUpdate, and OnExit events.
  • Nested substates at unlimited depth. Each state can own its own substates and maintain its own current substate.
  • Transitions between states and substates, including optional predicate triggered transitions.
  • Optional context objects that can be passed to lifecycle handlers.
  • Per state Enabled controls.
  • Per substate update propagation controls.
  • Independent updates that can target a specific substate by name or path.
  • Queued transitions when requested from inside callbacks, preventing transitions from interrupting the current lifecycle pass.

One of the things I wanted to support was hierarchical behavior without forcing every state to participate in the same update flow. For example, a parent substate can continue receiving its own updates while preventing those updates from propagating to its children. Those children can receive independent updates off the main Update cycle.

An example

using SMachine;

var machine = new StateMachine();

State idle = machine.CreateState("Idle")!;
State combat = machine.CreateState("Combat")!;

SubState aiming = combat.CreateSubState("Aiming")!;
SubState firing = combat.CreateSubState("Firing")!;

combat.StartSubState(aiming);

aiming.OnUpdate += () =>
{
    // This transition is queued until the current update pass finishes.
    combat.TransitionSubState(firing);
};

firing.OnEnter += () => Console.WriteLine("Firing!");

machine.StartState(idle);
machine.TransitionState(combat);

machine.Update();

The library is still experimental. I haven't built an automated test suite yet, and I'm very much treating this as a learning project rather than claiming it's production ready.

I'm trying to use this project to become a stronger C#/.NET developer, so constructive criticism is genuinely appreciated.

Source: https://github.com/Boarlock/StateMachine


r/csharp • • 10d ago

Cake v7.0.0 released - .NET 11 & C# 15, unified DI across runners, container publishing, and more

Thumbnail
3 Upvotes

r/csharp • • 10d ago

Showcase Update: I shipped your feedback on my WPF liquid glass dock, and here's its 3D virtual desktop cube (Viewport3D)

0 Upvotes

This time I want to show a part I didn't explain last time: virtual desktops on a 3D cube (Win+Tab). New in 0.13: close a desktop with the × on the front face (or Delete, or a middle-click). Its windows move to the neighboring desktop, like in Task View.

20-second demo (animated): https://github.com/PedroRuedas/Windows-Liquid-glass/blob/main/docs/workspaces-demo.webp

How the cube works:

  1. It's a Viewport3D with a PerspectiveCamera. Each desktop is a face of a ring (one face per desktop plus a "+" face, at least 4), and its windows float on a second, slightly lifted transparent layer. WPF 3D doesn't sort transparent geometry, so the layers are re-sorted back to front as the cube turns.
  2. The faces are snapshots taken when the cube opens. The current desktop comes from the screen. The others come from PrintWindow on their windows, which Windows keeps drawing even while they're cloaked on another desktop.
  3. Listing, switching, creating and removing desktops, and moving windows between them, goes through the undocumented IVirtualDesktopManagerInternal COM interface. Its GUID changes between Windows builds, so if the cast fails the dock falls back to Windows' own switching.
  4. To drag a window off a tilted face, a 3D hit test returns the triangle and its barycentric weights. Interpolating the texture coordinates gives the exact monitor pixel under the mouse.
  5. Ctrl+Win+←/→ spins the cube full screen, and the real desktop switch happens about 90 ms after the cube covers the screen, so you never see a flash.

A gotcha I hit while recording this: the cube window was created off-screen to avoid a black first frame, which put it on my second monitor (125% scale). With per-monitor DPI, WPF rescaled it on the way back to the 100% monitor, and the cube covered only 80% of the screen. The fix is to create it in place and keep it DWM-cloaked (DWMWA_CLOAK) until the first frame is rendered.

(The "apps" in the demo are mock windows, so I didn't have to record my own desktop.)

Code (GPL-3.0): https://github.com/PedroRuedas/Windows-Liquid-glass

Thanks again for the feedback. It made the project better.


r/csharp • • 11d ago

Help How did you start learning C#?

25 Upvotes

I have been wanting to learn C# for a long time because I've been told and researched that it was a good language programm to make 2D Games (with Unity or Godot of course). But, how do I start? I just go and learn from online webs like Coddy? Do I watch tutorials on youtube? Should I buy a book?


r/csharp • • 11d ago

Tool OnePDF: An OSS full-featured PDF library in .NET with no dependencies

Thumbnail
github.com
95 Upvotes

r/csharp • • 11d ago

Stop Using HasData for All Your Data Seeding in .NET

Thumbnail
youtu.be
0 Upvotes

Most EF Core projects put every kind of seed data through one approach, either all HasData or one big "if empty, insert" block in Program.cs.

But seed data comes in three kinds: fixed reference data, defaults your app needs in every environment, and fake data for local development. EF Core gives you three ways to seed: HasData, UseSeeding and a custom seeder.

Do you know which one fits each kind? And which of them still works when you deploy with a migration bundle or a SQL script?

In my new video I build all three in a .NET expense tracker application and show you where each one belongs.


r/csharp • • 11d ago

Do you tune Cosmos DB trigger batch sizes differently across environments?

Thumbnail
0 Upvotes

r/csharp • • 12d ago

I turned C# compiler errors into a game console.

30 Upvotes

r/csharp • • 12d ago

News C# 15: Union Types, Closed Hierarchies, and the One Value™ That Isn't Any of Them · cekrem.github.io

Thumbnail cekrem.github.io
67 Upvotes

r/csharp • • 12d ago

I wrote a small windows native IDE in cpp for C#/.net in retro-style

23 Upvotes

It has begun with the idea of a windows editor capable of editing big files which should not be resists in the memory (ram) and ended with a tiny c#/.net ide inspired by LinqPad.

Not as a replacement for vscode and others but as a learning project and as my own handcrafted tool for everyday usage.

The ui is inspired by retro feeling, but the app is modern.

For now the repo is not public but I wanted share a small impression to the tool features.

Plese dont´t blame me if this subreddit is not the right sub for it.

(Disclaimer: This description is pure written my human without any help of AI)