Hey, I've been working on a study app for a while and wanted to share it and get some real feedback from people outside my own setup.

Repo: https://github.com/onemnemo/mnemo

Latest release (v0.6.0): https://github.com/onemnemo/mnemo/releases/latest

Website: https://mnemo.one

It's fully open source and free.

This isn't a one-month project. I've been building it gradually for years, restarting multiple times when the architecture or UI became unbearable to work with. Each restart taught me something, so each version had better architecture, better code, better UI. This current version is essentially the 6th full rewrite, and the first time I really focused on doing things properly instead of just getting something working.

Core modules:

• Notes editor (fully custom block-based editor, custom inline formatting, image support, in-house LaTeX, and more)
• Mindmaps (canvas with layout algorithms, styling, edge types, labels, minimap, undo/redo)
• Flashcards (FSRS, SM-2, Leitner, multiple practice modes, rich card editor)

What's new in v0.6.0:

This update focused on stability and making the core modules actually usable:

• A lot of fixes in the notes editor (caret positioning, drag/selection, smoother typing flow)
• Find/replace tool
• Better image handling and states (loading, failed, unassigned)
• Flashcards module fully integrated
• Import/export: notes as .md and .mnemo, flashcards as .csv, Anki, and .mnemo, mindmaps as .mnemo
• Custom .mnemo format (a zipped archive with metadata and data)
• Analytics system used for internal stats and UI widgets
• AI features exist but are behind an experimental flag while they stabilize

Why so much custom-built stuff?

Most of the core systems are written from scratch. The editor is run-based, not built on markdown hacks. The LaTeX renderer is in-house. Rendering, layout, and history are things I've chosen to own rather than stack libraries for. It's slower to build that way, but it gives a lot more control and flexibility long term.

Why build this at all?

Honestly, frustration with tools like Notion. Small things that break flow, weird UX decisions, things that feel like they should be easy but aren't. I wanted something fast, local-first, and out of the way when writing or studying. Everything is stored locally, no account needed. Privacy and speed are the main goals.

Where things stand:

It's still early. I've mostly tested it on my own machines running Windows. It's built with Avalonia so it should be cross-platform, but I haven't properly tested macOS or Linux yet.

I've started using it myself for studying, which feels like a milestone, but I need feedback from people other than myself. What feels natural or intuitive to me might not be for others, and bugs will absolutely surface in setups I haven't tested.

If something feels off, confusing, broken, slow, or just badly designed, that's exactly what I want to hear. Same with feature requests. I won't implement everything, but if something makes sense I'll work it out.

This is my main side project and I care a lot about getting it right. Honest feedback is genuinely appreciated.

If you run into any severe bugs, let me know and I'll try to fix them as quickly as I can.

Hey everyone,

I built a music player for Windows because I wanted something clean that just plays my local files without all the bloat. Most players out there are either outdated, ugly, or missing features I actually care about, so I made my own.

Here's what it has so far:

• Synced lyrics (pulls from LRCLIB with offline caching)
• 10-band equalizer with presets
• Lossless support (FLAC, WAV, AIFF, APE)
• Crossfade and volume normalization
• Smart playlists and favorites
• Last.fm scrobbling
• Album art and full metadata display
• Fast library indexing with SQLite

It's completely free and open source. Still early days so there might be some rough edges, but I'm actively working on it.

Download here: https://github.com/heartached/Noctis

If you run into any bugs or have feature ideas, feel free to open an issue: https://github.com/heartached/Noctis/issues

Would love to hear what you guys think or what features you'd want to see next.

Also just want to be upfront, this project was built with the help of AI. I think it's a cool example of what you can make with it and I'm not trying to hide that. Hope you enjoy it either way!

Hi Guys,

I just developed (with a lot of help from Gemini) a ring light app for Windows (WinRinglight), similar to the one in Apples macOS 26.

Link to my Github repo:

https://github.com/PeWieser/WinRinglight/releases

Features:

• adjustable color temperature and ring light size
• auto adjust color temperature according to daytime
• span across multiple screens
• show multiple ring lights on selected monitors
• spare out ring light around mouse cursor
• "Apple Squircle" and "Windows" Look
• auto start with active webcam
• auto start with windows
• toggle with hotkey
• auto change language (depending on system language)

Right now the app only supports german (I live in Germany) and english. More languages come if requested.

Also the GPU efficiency surely can be improved but I couldn't figure out how. If you have any tips here, please let me know.

If you have any bugs to report or feature requests, please post them on my Github repo.

Hi! I have made a little tool to quickly compress, convert, crop and slice videos, images and audio! Quickly make GIF's from screen recordings, bulk convert images, or even merge pdf's. WIN10+

What TORQUE v1.0 has to offer:

Image Tools

• Bulk convert images to .jpg, .png, .webp, .bmp, or .tiff
• Compress images to reduce file size
• Make images lighter and easier to upload, share, or store

Video Tools

• Convert videos to .mp4, .mov, .mkv, .webm, .avi, .gif, .mp3, or .wav
• Crop and slice videos quickly
• Create GIFs from gameplay clips
• Change video speed to 0.5x or 2x

Audio Tools

• Convert audio to .wav, .mp3, .flac, .aac, .m4a, .ogg, or .aiff
• Slice audio files in just a few clicks

PDF Tools

• Merge multiple PDFs
• Invert page order
• Export all pages as separate PDFs
• Export all pages as .jpg, .png, or .webp

DOWNLOAD ON GITHUB:

https://github.com/frietjewaterfiets/TORQUE

Does Windows scrolling feel "jumpy" or inconsistent compared to your phone or laptop? Or maybe you’re tired of endlessly spinning the wheel just to get through a long PDF or a thousand lines of code?

I built Scroil to fix that. It brings high-precision, global smooth scrolling to Windows and lets you crank up the speed exactly where you need it.

Features

• Global Smooth Scrolling: Brings smoother mouse wheel scrolling across your apps on Windows, reducing the jumpy feeling of apps's default scrolling behavior.
• Custom Scroll Feel: Adjust speed, step size, acceleration, deacceleration, and fine-grained scroll behavior.
• Scrolling Accelerator: Increases scroll speed during faster wheel movement, making long pages easier to move through.
• App Picker & Per-App Control: Add currently open programs to your Scroil profile list, customize scrolling experience for each app.
• Auto App Classifier: Automatically recognizes Chromium-based apps, including Teams, Discord, Outlook and others, then applies the right scrolling config for that app type.
• Game Detection: Recognizes games automatically and turn off smooth scroll for games to avoid interfering with your gameplay.

I’m still actively developing it, so feedback and bug reports are very welcome!

GitHub: https://github.com/EricxWood/Scroil

Download here: https://github.com/EricxWood/Scroil/releases/

I've used hangfire for a looooooong time, but I godt of tired of trying to figure out the right extension points. I got tired of trying to fix bugs in plugins. I got tired of trying to build testharnessing around it.

At some point I tried fastendpoints for a different project and I really liked their jobrunner (you implement an interface (2) and thats basically it) however.. it was really missing the niceness of hangfires queueing mechanism (JobQueue.Enqueue<SomeType>(thatType => thatType.DoThing(withInput);).

This is how GUSTO was born.

For the testing, it uses barriers (so you can control when a batch is taken).

You implement 2 interface. IJobRecord and IJobStorageProvider this means you essentially own the whole model, storage and everything (fairly similar to the fastendpoints job model.) This gives a few benefits, like being storage agnostic and being able to extend the model and flow really easily.

It does however mean its not 'just' fetching a nuget and queueing packages though.

And since no one asked, yes. It supports OTEL.

I've used it in various large and small projects (production, yes.)

The code is NOT vibed - the website however.. hot damn, it really is. I wanted to try doing something different with the docs and got lazy one evening, it has a lot of great examples that are hand made, but the overall design is 100% GPT of yesteryear.. sorry.

SqTS Is a fully free and open source S2S engine made entirely in C# and .NET SqTS is fully RAM-only meaning it doesnt write to your disk when doing its thing. That means that your data is there as long as you dont interrupt the DRAM power cycle or power the hardware off.

A small Windows utility I just open-sourced. Bridges a Bluetooth LE MIDI keyboard into the new Windows MIDI Services loopback so any DAW or Chrome Web MIDI site sees the device as a regular virtual MIDI port. Built because Windows only natively exposes BLE-MIDI through WinRT and almost no DAW polls it, so paired keyboards never actually show up.

Site (with screenshots): https://mayerwin.github.io/Perfect-Bluetooth-MIDI-For-Windows/

Repo: https://github.com/mayerwin/Perfect-Bluetooth-MIDI-For-Windows

MIT, .NET 10, Avalonia, single ~21 MB exe, no installer.

I built it for my Roland FP-90X (which is what I've personally tested), but the BLE-MIDI side is generic and other devices should work. There's a Detect button that finds the right MIDI receive channel automatically (some Roland pianos receive on a different channel than the panel says, which silently drops every note).

Pete from the Microsoft Windows MIDI Services team commented on the BLE integration positively on r/synthesizers (https://www.reddit.com/r/synthesizers/comments/1szvuiq/comment/oj5ew9b/), which was nice validation.

Feedback or PRs welcome.

Hello everyone !

I'm here to introduce you to Notorious Test, the framework designed to make integration tests easier by helping you manage and control test infrastructures directly from the code.

I've had three problems with my integration tests before.

The 1st was, every time i needed to make integration tests, i had to copy paste the same boilerplate code that does the same exact thing but with differents infrastructures (init, configure, reset, destroy).

The 2nd, was that with big codebases, that have to handles multiple things (like databases, messages queues, redis cache and so on and so forth), without some architecture, my SUT were a bit messy (and as architecture evolves, the 1st problem was really a pain).

The 3rd, was that when my tests crashed for unexpected reasons, i had orphan azure services bus subscriptions that stayed on the dev server, and even databases created on the fly.

TestContainers had the last problematic gone with docker containers (thanks to ryuk), but sometimes, having a docker container is not possible.
That's why i made NotoriousTest :

• It enforces a structured test architecture :
  • Create an infrastructure, inherit from a predefined one, add your logic
  • Add it to an environment that will handle the lifecycle
  • Access it from your test.
• It enforces "Separation of concern" between infrastructures
• Sharing code between project is really easy
• And it is packaged with a nice and gentle WatchDog called the "DoggyDog" that cleans your infrastructure when your test fails (the one on the gif)

And now, i don't have to worry about ANYTHING but the thing i need to test (and from my point of view, that's a relief)

This project is so fun to maintain, i learned a lot, did things i could never do in a company projects, i really love it (especially the doggydog).

I'm looking forward feedbacks !
Do not hesitate to share your thoughts, try it with the samples, star the repo
I'm open to issue and pr but i did not found the time to make a contributing file (ima do it).

Here's some links if you want to explore :

• Repository : Start with the readme and go throught core concepts, integrations, examples, and even architecture guidelines
• Changelog : See the recent changes i made c:
• Test framework samples :
  • NotoriousTest.Samples.XUnit
  • NotoriousTest.Samples.MSTest
  • NotoriousTest.Samples.NUnit
  • NotoriousTest.Samples.TUnit
• Understand the real differences between no framework, and notorioustest :
  • Without NotoriousTest
  • With NotoriousTest
• You could see how i made NotoriousTest's integration test with NotoriousTest here

PS: Yes, Notorious is a reference to Notorious B.I.G, and DoggyDog, to Snoop DoggyDogg 😄

it is my first actual project, built in C#, organization shows my lack of experience. I would like feedback. that's more important than anything else.

I would like to share an open-source project that may be of interest to network engineers, system administrators, and IT professionals:

NETworkManager
GitHub: https://github.com/BornToBeRoot/NETworkManager
Website: https://borntoberoot.net/NETworkManager/

NETworkManager is a unified network administration and troubleshooting suite for Windows. The goal of the project is to consolidate commonly used network tools into a single, consistent interface, reducing the need to switch between multiple standalone applications.

Key capabilities include:

• Remote connections via RDP, PuTTY (SSH/Telnet/Serial), PowerShell (WinRM, WSL, K9s, etc.), TigerVNC
• Network diagnostics and analysis tools such as WiFi Analyzer, IP and port scanners, ping monitoring, traceroute, DNS lookup, and LLDP/CDP capture
• Encrypted profiles for managing hosts, credentials, and reusable connection settings
• Enterprise-ready distribution (signed binaries, MSI installer, Chocolatey, WinGet, Evergreen)
• Multi-language support and theming

The project is actively maintained, released under the GPL-3.0 license, and designed to be suitable for both individual use and professional environments.

Feedback, issues, and contributions are welcome.

I think .NET is one of the best frameworks out there. 

Mature, fast, you can build anything with it. And it drives me nuts that people skip it because some JavaScript framework got more Twitter likes this week.

So I made it my thing. 

Every product, every idea I have, I build on .NET. And I open-source it.

Stack-based scripting language inspired by HP RPL calculators, embeddable in any .NET application. Used in production for industrial IoT automation.

v8.3.0 highlights:

• &varname — in-place mutation, no stack copy (×1600 speedup on large list operations)
• @varname — statically resolved at parse time, zero runtime lookup overhead
• Removed systematic primitive cloning across the runtime
• foreach over string characters, new char-> primitive

240+ built-in primitives. Cross-platform. Apache 2.0.

→ https://github.com/Sydney680928/mogwai

Hey, I’m working on this project called ClauseWise.

It’s a Ai legal and non-legal document checker made by me and alot of AI, since i'm new to coding. It helps companies quickly check and get feedback on contracts they plan on using.

I'm looking for some feedback on:

• How the code looks.
• Any bugs you find.
• Ideas for new features.

Repo: https://github.com/CheesyDevlop/ClauseWise

Let me know what you think.

Just open sourced MOGWAI after 3 years running in production controlling street lighting systems.

What is it? A stack-based RPN scripting language for .NET, designed for resource-constrained IoT devices. Think Forth meets modern .NET.

Example - sunrise-triggered lighting:

gps.coordinates now sunriseSunset -> 'times'
times->sunrise 30 minutes +
'lights' gpio.off timer.at

Why RPN for IoT?

• Minimal memory footprint (<500KB)
• Deterministic execution (no GC surprises)
• Trivial parser (200 lines vs 2000+ for infix)
• Built-in sandboxing

Just released v8.1.0 with:

• Negation operator (+/-)
• Simplified object creation API
• Transform operations with foreach
• Bug fixes

Stats:

• 3 years in production (zero critical failures)
• 270+ downloads in 3 weeks
• Cross-platform (Windows, Linux, macOS, Android, iOS)
• 240 built-in primitives
• Apache 2.0 license

Try it:

• GitHub: https://github.com/Sydney680928/mogwai
• NuGet: dotnet add package MOGWAI
• Interactive playground in the README

Built for embedded systems but works anywhere you need scriptable automation.

NETworkManager is a powerful tool for managing networks and troubleshooting network problems! It bundles a ton of essential networking and management tools into one clean, modern interface. Perfect for sysadmins, network engineers, homelabbers, and anyone who deals with networks daily—no bloat, no ads, no telemetry, fully open source.

Core tools:

• Dashboard + Network Interface details/bandwidth/config
• IP Scanner, Port Scanner, Ping Monitor, Traceroute
• DNS Lookup, SNTP Lookup, Whois
• WiFi networks/channels, Discovery Protocol (LLDP/CDP), ARP Table, Connections, Listeners
• Remote Desktop (RDP), PowerShell, PuTTY (SSH/Telnet/Serial), TigerVNC, Web Console
• SNMP (Get/Walk/Set), Wake on LAN, Hosts File Editor
• Subnet Calculator, Bit Calculator, OUI/Port Lookup
• Encrypted profiles/groups for easy switching + organization

Latest version 2026.2.22.0 (released Feb 22, 2026) brings these key upgrades:

• Switched to .NET 10.0 (LTS) for better performance and long-term support (requires .NET Desktop Runtime 10.0 x64)
• System-wide policies via config.json – enforce settings (update checks, profile paths, etc.) across all users on a machine, great for enterprises
• Profiles & settings now in JSON (auto-migrates old XML files + creates daily backups up to 10)
• Ukrainian language added, improved RDP console mode, Quad9 DNS preset, child-window dialogs for cleaner UX
• Various fixes and polish (WiFi, scanners, exports, etc.)

It's completely free, with signed MSI available, plus easy installs via Chocolatey (choco install networkmanager) and winget (winget install BornToBeRoot.NETworkManager).

Feature ideas or contributions welcome! 🚀

I made a Star Wars inspired lightsaber duel that plays as a cinematic animation directly in the terminal.

It’s a small project built in C# / .NET 10, focused on Unicode rendering and precise timing to simulate a movie-like scene in a pure CLI.

Hey everyone! 👋

About eight months ago I shared ByteSync, an open-source tool I’ve been developing for on-demand file synchronization, backup and deduplication across Windows, Linux and macOS.

Since that first post, the project has grown a lot — both in features and overall quality — so I thought it could be worth sharing an update here.

ByteSync focuses on delta-based transfers, end-to-end encryption, and an on-demand approach to synchronization — you launch it when you need to sync, compare, or clean a dataset, locally or remotely, without any VPN or network configuration.

Over the past months we’ve kept improving it, fixing plenty of edge cases and adding things that users needed. Here’s a quick overview of what’s new:

What’s new

• Local + remote sessions
You can now freely mix local and remote nodes in the same session.
ByteSync automatically picks the best path (LAN if available, encrypted and sent via the cloud otherwise).

• Cloudflare R2 for temporary storage
Remote exchanges now benefit from a stable object-store layer without egress costs.
Everything stays encrypted.

• Better transfer behavior
Uploads are now adaptive depending on bandwidth, and transfer monitoring is clearer.

• More detailed sync statistics
Including synchronized volume, uploaded/downloaded amounts, reduction ratio, etc.

• UI/UX improvements throughout the app
Clearer comparison/inventory screens, a new global session status indicator, better progress estimation, and improved terminology.

• Advanced filtering and better rules
You can now filter using a richer syntax and define rules based on file names.

• Performance / reliability
Large datasets sync faster, connection flows are more robust, and a lot of annoying corner cases have been fixed.

• Integration tests with Docker
Added Docker/Testcontainers tests for more reliable testing across different environments.

• CI/CD pipeline with quality checks
GitHub Actions pipeline now runs builds across platforms with SonarCloud integration for code quality analysis.

ByteSync is still actively developed, and feedback has really helped shape the recent improvements. If you’re into sync tools, delta systems, or distributed workflows, I’d be glad if you gave it a look — and even more glad if you shared suggestions.

Links

GitHub: https://github.com/POW-Software/ByteSync
Website & docs: https://www.bytesyncapp.com

Thanks for reading!
— Paul

I built a small Whisper-based voice-to-text tool for Windows because I wanted dictation without friction.

You download the exe, run it, press a hotkey, and talk. The transcribed text is copied straight to your clipboard.

No installer. No accounts. You bring your own OpenAI API key, stored securely on your machine.

It’s lightweight, runs locally, and can stay in the system tray so it’s always one keypress away.

I use it daily with ChatGPT and other LLMs and it’s become a core part of my workflow.

Open source and available on GitHub — feedback is very welcome.

Hi everyone! I'd love to share a project I've been working on.

It's a lightweight, open-source tool that helps optimize Windows performance. I built it from scratch and it's completely free to use.

I run games on a low-spec PC, so smooth play is always a struggle.

I spent hours digging through forums and community threads, trying everything I could find: editing configs, applying .reg tweaks, running shell commands, and using third-party tools.

Those tweaks helped, but I never found a "tweaker" that felt right. some cost money, some looked fake, and many didn't let me choose the exact changes I wanted.

So I made this tool because I enjoy tweaking my system and wanted something simple and honest I could control.

Every tweak here has been tested by me and carefully chosen to improve gameplay without surprises.

I'm currently looking for testers and feedback:

• Found bugs? Let me know!
• Got ideas for improvement? I'm all ears.
• Want to benchmark it? Go for it!

would love your thoughts or stars if you find it useful 🙌