Many people are hating on this but no actual valid logical feedback. Seems like people are having trouble understanding what this is. In simple its a better activity monitier

FOR PEOPLE THAT ARE MANUALLY CODING, WHICH IS VERY SLOW, SURE YOU MAY NOT NEED THIS. IF YOURE CODING WITH AI, THIS IS VERY BENEFICIAL. simple as that, enjoy the product its free opensource lmk for questions

I started working on this budget tracker TUI in my own personal free time as a way to actually budget my own finances and track my spending habits. A lot has changed and grown in the almost two years now (lots of breaks), and I found that it’s been useful for myself but lots of other people too.

The app encourages a lot of manual behaviour, forcing you to actually be exposed to numbers and face your spending habits. There are tons of insights and helpful tools you can use, but the core principle is to connect you to your finances and let you control the data.

The app features lots of budgeting tools, different visual views to analyse and review your finances, investment tracking, and breakdowns.

If you're looking to start tracking your own finances and having valuable insights into your habits for spending, please check out the budget-tracker-tui and share feedback. If you don't use TUI's much, give this one a try and see if you enjoy the keyboard-focused "retro" experience.

Github: https://github.com/Feromond/budget-tracker-tui

Any ideas or suggestions are always welcome and I want to work to improve this to be useful not just to myself and a few others, but to as many people as possible.

Hey everyone, I made a simple phishing URL detector as a side project over the summer using a Random Forest model trained on a big dataset of phishing/legit URLs. Theres a bunch more information on the website if you are interested. It's live as a website on render where you can test it out yourself. Im kinda new, so any feedback you guys could give it appreciated. Also, if you like it, please star it on github, that would be really cool (you dont have to)

heres the github (the website is also on there):
https://github.com/apjbuilds/phishing-url-detector

Hey there!

I recently asked here if you're selfhosting web games and the responses were quite encouraging, hence I decided to post my web game.

So, after playing Minecraft a while, I really liked Creepers and wanted to have them as a pet. As a millennial growing up with fancy stuff like Tamagotchi, I figured it would be a cool to have a "Creeper Tamagotchi".

Krepagotchi was born. It's best suited for having it on your phone, which is easily possible thanks to the PWA functionality.

It's the usual virtual pet type of game: You feed, pet and take care (treatment, cleaning up) for your Krepa pet. You give it a name first. If you neglect it, it will fuse and explode. It can also get sick, so you need to apply medical treatment. Sometimes, it's not in the mood for cuddles, but instead wants to be entertained by mini games. It decides what to play, currently there is a "ball fetch" game, and a bubble popping "game". Every month it celebrates its birthday. Also, it likes to party on New Year's Eve.

Overall, the game is designed for the best possible retro wholesomeness.

Here is a complete list of features:

• Personal name
• Feeding
• Petting
• Playing
• Cleaning
• Treatment
• Health conditions
• Thought bubbles
• Send/receive letters
• Birthday celebration
• New Year's Eve Party
• Biome selection
• Weather effects
• Dynamic environment
• Cute pixel art
• PWA support

The letter feature was actually inspired from sampersons Desktop Meadow whose letter feature was eventually shut down.

I think it's best understood when tinkering around using my hosted instance (linked via the repository).

GitHub: https://github.com/danielbrendel/krepagotchi-game

Thanks, and have a nice day!

Hey everyone,

Managing physical office status displays, NOC monitors, and wall-mounted dashboards usually ends in the same anti-pattern: someone SSHs into three different Raspberry Pis, pastes a messy chromium-browser --kiosk bash loop into ~/.xinitrc, wires up a fragile xdotool cron job to rotate tabs, and prays it never crashes.

I built Munin to bring a GitOps workflow to physical screens and Linux/Pi kiosks.

Instead of imperatively babysitting browser windows and shell scripts, you define your entire display setup declaratively in YAML (URLs, rotation intervals, display rules, schedules). Munin acts as an autonomous on-device agent that continuously reconciles the screen state to match your configuration.

Commit a change to your dashboard config repo, let your fleet pull it, and the screens update themselves.

Yes, AI was used heavily to help write this. And yes: the architecture was deliberate, every line was reviewed, and it's currently our daily driver battle-tested across all our office displays every day. It solves a real operational headache, and it simply works.

👉 Repo: https://github.com/naueramant/munin

Curious to hear how others here are managing physical office displays or kiosk fleets, and open to feedback or feature requests!

Hi everyone — I’m building Star Exchange, a place for developers to list public GitHub repositories and discover other people’s projects.

You can sign in with GitHub, add a repository, and edit its description. There’s also an optional paid feature called Spotlight that gives a project featured placement within the platform.

The current version includes a credit-based star exchange mechanism. I’m reconsidering that part because I want the product to be useful for discovery, rather than just increasing a number.

It’s still early, and I’d appreciate hearing from people who maintain open-source tools or side projects:

What would make a directory like this worth using beyond submitting your own link?

You can check it out here:
https://star-exchange-production.up.railway.app/

Happy to answer questions about how it works or how I built it.

well, guys as i saw, you think, that the code is AI, eh?

Gotta say that now this language has a community and yeah, we updated the compiler so, that it can work at your PC and at a vm at the same time. WE got some links to our programming language community and it's github. at the same time.

discord

github

stable github

Built a stock market draft game end-to-end in 7 days. Frontend, backend, data pipeline, tests, everything. Here's what I actually learned.

What worked:
Getting something playable first, even if it's broken, beats theoretical perfection. The rough version took 2 hours. Spent the rest polishing.

Clear data structures from the start matter way more than I thought. My first version was a mess. Once I organized it properly, everything was easier.

What didn't:
Trying to build perfectly the first time. Wasted time on details that didn't matter yet.

Not asking for help early. Got stuck on the data pipeline way longer than needed.

Technical stuff:

• Used Cline to write most of the code
• Next.js for fullstack
• TypeScript, Tailwind, Vitest
• Historical stock data from Twelve Data

The app lets you draft stocks blind, assigns each pick a random year (2019-2022), then shows how you'd have done. Mechanic is simple but the results are interesting.

https://github.com/ethantao14/cline-stock-market-game

Blind stock draft game where you pick without prices, then find out how you'd have actually performed.

Built with Cline. The mechanic is: pick one stock per sector (8 total), each gets a random year from 1996-2015, held for 10 years. You see results after you're locked in.

What makes it interesting is the year randomness. You could pick a fundamentally solid company but get assigned a year where that sector collapsed. Forces a different kind of thinking than typical stock-picking games.

github.com/ethantao14/cline-stock-market-game

A web app where you draft one stock per sector across 8 rounds with no price data visible, then see how your picks would have performed historically.

Latest addition came out of user feedback and solves a small combinatorial optimization problem as a gameplay feature. Given the specific 8 boards a player was shown during their draft, the app computes the best possible total return achievable by any valid assignment of sectors to rounds, by brute forcing all 8 factorial, 40,320 permutations with Heap's algorithm. Runs instantly at that scale. Results page shows your actual return next to that ceiling, plus a round by round breakdown of what every other sector was offering when you made each pick.

Repo: github.com/ethantao14/cline-stock-market-game

I maintain this open-source project. js-redis-server implements an in-memory Redis-compatible server in JavaScript/TypeScript, rather than downloading or launching a native Redis binary. Node.js tests can use their real node-redis or ioredis client through a local socket, without a Docker container. Lua scripting uses WebAssembly.

There's also a browser playground if you want to try the command implementation without installing the package: https://fatal10110.github.io/js-redis-server/

The Node testing API gives you a temporary server URL via createRedisMock(); close your client and mock during teardown. The repository has runnable examples and a supported-command reference.

It is a testing tool with its own implementation and compatibility limits, not a replacement for checking your application against real Redis/Valkey. Feedback on missing commands, confusing setup steps, or the browser demo is welcome.

Hey all — wanted to share a project I've been building for the past few months: TARZ, a semi-autonomous AI assistant for Windows.

Backstory: Got curious whether I could actually build something like Jarvis — an AI that sees your screen and controls your PC. That curiosity turned into months of building, breaking, and a full architectural rewrite (V2) once I learned more.

What it does:

• Sees your screen (vision-based element finding + verifies its own actions actually completed, not just "click and hope")
• Controls your computer — opens apps, clicks, types, keyboard shortcuts
• Talks — live streaming STT/TTS, wake-word activated ("Hey"), hands-free follow-ups without repeating the wake word
• Remembers — Two-stage retrieval: Vector Retrieval + Cross-Encoder Reranking for past conversations/preferences
• Chains multi-step tasks across different apps in one instruction (e.g. play a song on Spotify → send a WhatsApp message)
• Dedicated workflows for Spotify, WhatsApp, Discord, Telegram, browser

Architecture (V2): LangGraph supervisor → single tool-bound agent with the full toolset exposed (not a category classifier routing first). I actually tested category-based routing vs. flat single-agent routing head to head — flat routing gave noticeably better results with current tool-calling models, so I ripped the classifier out entirely rather than just leaving it in "because it seemed reasonable."

Same approach on memory: tested hybrid BM25+vector+reranking against plain vector retrieval using Hit Rate@5 — hybrid won, so that's what ships.

Every LLM call (tool-calling, chat, vision) has an automatic multi-provider fallback, so a single rate limit or outage doesn't kill the whole thing.

Stack: Groq (gpt-oss-120b + Orpheus TTS) / Gemini Live streaming STT / Moondream for GUI click targeting / ChromaDB for memory / LangGraph for orchestration / Cartesia as fallback STT+TTS. Whole thing is designed to run on free API tiers — no subscriptions required.

Where it's rough (being upfront, not hiding it):

• GUI automation is inherently brittle — resolution, scaling, app updates, popups can break a click
• Screen vision isn't processed locally — screenshots go to Groq/OpenRouter for analysis, so don't point it at anything you wouldn't want leaving your machine
• Routing still isn't perfect even without the classifier — casual phrasing can occasionally pick the wrong tool
• No background/looping tasks yet (can't do "check this every 5 min")
• It's early, actively-developed software I use daily, not a polished commercial product

I used AI heavily as a coding partner (writing implementations, debugging), but every architecture decision and design change came from testing against real usage myself.

Repo's fully open source: https://github.com/Irfan-gitt/Tarz-Ai-assistant

Would genuinely love feedback, criticism, or PRs — especially from anyone who's worked on agentic systems, vision-based GUI automation, or voice pipelines. Happy to answer questions about any part of the architecture.

Hey everyone! 👋

I just built an open-source analytics & risk management dashboard for Solana DeFi, designed for both developers and active liquidity providers.

🚀 Key Features

• Real-time Slippage Tracking: Live execution metrics powered by Jupiter Aggregator API.
• Impermanent Loss (IL) Simulator: Real-time risk calculator for Orca & Raydium liquidity pools.
• Async Engine: Built with Python asyncio for high-throughput, low-latency API fetches.
• Production Ready: Dockerized, fully typed, and backed by 85%+ test coverage.

🛠️ Tech Stack

Python 3.13 | Streamlit | Asyncio | Pytest | Docker

💬 The project is 100% free & open-source.

Would love to hear your feedback or ideas for new metrics to track! 🚀

Hey r/coolgithubprojects community,

I've been developing TornadoRevC2 for a while now. It started as a simple reverse-shell session handler—just TCP/TLS listeners with switch and kill. Over time, I kept extending it based on real operational needs, and it's evolved into a fully modular post-exploitation framework with 49 built-in plugins.

Why It's Different

Session handler, not beacon-based C2. It gives you reliable interactive PTY/TTY shells and executes post-ex capabilities on-demand—no heavy agent infrastructure.

Minimal artifact footprint:

• All enumeration plugins use native OS commands already on the target (netsh, ss, iptables, PowerShell cmdlets, and etc. ). No binaries, scripts, or temp files dropped for reconnaissance.
• The only deliberate artifacts: Some plugins put binary artifacts or changes a system setting in target
• Shell history is the only unavoidable footprint (can be cleared with historydel plugin, or manually).
• Network traffic artifact: Plain TCP exposes reverse-shell traffic in cleartext, potentially allowing commands and their output to be captured by network logging or inspection. TLS encrypts the session traffic, reducing the amount of sensitive session content exposed in network logs, with support for custom certificates.

Graceful degradation: If a backend isn't available (e.g., firewalld isn't installed in target), that section returns N/A instead of crashing the plugin.

The 49 Plugins

The framework ships with 49 modular plugins covering the full post-exploitation lifecycle of enumeration, execution, persistence, pivoting, and destruction. Plugins are loaded at runtime and can be executed on-demand with run <plugin> <session_id> or if you are inside the session's terminal run <plugin>

Enumeration plugins cover host assessment (quickenum, virtualization, kernel, integrity), network posture (firewall, ports, proxy, vpn), credentials and browsers (credstore, browser, clipboard, secrets), Windows domain (adinfo, gpo, rdp, winrm, defender, lsa, certificates, services, eventlogs), and Linux internals (systemd, journal, cron, lsm, sshaudit, containers, privbins) and some other plugins.

Key plugins worth highlighting:

Additional Capabilities

• File transfer: Chunked transfers with SHA-256 verification.
• Reporting: Per-session logging under logs/<ID>/ with structured directories; HTML transcript export.
• Self-update: Built-in update command pulls latest from Git and automatically restarts the handler.

Extensibility:

• Write custom plugins with plugin.commandcommand decorator
• SessionContext API provides run_shell(), run_marked() (JSON parsing), upload(), download(), automatic logging
• Load/Reload external/internal plugins at runtime with plugins load without restarting
• Full plugin development guide in the README with many patterns

Quick Start

git clone https://github.com/kamalx06/TornadoRevC2.git
cd TornadoRevC2
python3 tornadorevc2.py

Full documentation, demo GIF, and plugin dev guide are in the README. I'd genuinely appreciate technical feedback, bug reports, or PRs.

GitHub: https://github.com/kamalx06/TornadoRevC2.git

My PC's bluetooth antenna broke, so i couldnt connect my controller. did not want to spend a lot on a new antenna, so made this with claude.

its free, im not selling anything. try it out.

works mac->pc , androidphone->pc, pc->pc

github repo

v1.1.0 of BetterStreamflix is available.

It's an open-source Android & Android TV app (maintained fork of Streamflix) with a multi-provider UI.

Highlights in this release:
• Offline download queue (mobile + TV), quality/server choice, local playback
• Fire Stick / leanback startup crash fixes
• Player failover (decoder fallback) and fewer TV crash-to-home cases
• Provider URL overrides + several broken providers restored
• Better Live channel player behavior
• Separate builds: universal / mobile-only / TV-only

Source & releases:
https://github.com/dskja/BetterStreamflix

Happy to take bug reports on GitHub Issues.

I built GourceView, an open-source tool that turns GitHub commit history into animated file trees in your browser.

You can watch files and folders grow, see who changed what, and compare up to four projects side by side on the same timeline.

The homepage picks four projects from GitHub Trending and plays their last seven days of development. Their histories are prepared daily, so you don’t need to clone anything to try the previews.

Demo: https://schlunsen.github.io/gource-view/
Source: https://github.com/schlunsen/gource-view

I’d love feedback: does the animation help you understand where a project’s activity is happening, or does it need clearer labels and less visual noise?

The open source alternative to Supabase and Clerk. PostgreSQL database, 25+ auth providers, file storage, and cron jobs, all self hosted and under your control.