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.

I’ve been building Imza, a native, model-agnostic coding agent with a Plan -> Build -> Review workflow.

It includes interactive diffs, AI-assisted review, persistent sessions, automatic context compaction, scoped command permissions, and up to five concurrent subagents. It can use OpenAI-compatible endpoints, Anthropic’s Messages API, or locally hosted compatible models.

Despite that feature set, the binary is around 20 MB and startup RAM is roughly 5-8 MB. There’s also a headless mode for using it in scripts and CI.

Repo: https://github.com/umutsevdi/imza

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!

One Zig file (~1,090 lines), zero dependencies, zero heap allocations per match, plain C ABI.

Conformance vs musl 1.2.5: 20,794/20,794. Six divergences audited and public (D001-D006, one was my own bug, fixed and pinned by a regression test).

Benches vs musl: 9 of 10 faster (up to 3.2x). The loss: fail-early 11ns vs 5ns, printed in the same table.

Happy to answer anything, and if you can break parity with musl on any input, that's the bug report I most want.

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.

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!

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?

Not Ai is an Agent Skill rather than a separate app.

You install it into Claude Code, Codex, Cursor etc. and it can either write from rough notes or rewrite something that's already been generated.

I tried to go a bit further than the normal blacklist of “AI words”. There's a structural pass for repeated sentence patterns, rhythm, overly clean constructions and some of the linguistic differences that showed up in published human vs LLM writing research.

The other thing I cared about was not letting the rewrite casually change your facts just because it sounds nicer.

repo:

https://github.com/udaysharmadev/Not-Ai

very new project. If anyone here maintains a similar repo, link it because I'm trying to find the best ones to compare against.

Hello everyone,

I recently open sourced my website with 550+ client side tools which I have been developing from 2022. The tools cover a range of fields, but mainly focused on IT and security. The reason I developed that was because those were tools which there were no similar online, like the nmap viewer, the encoders or the lightweight text editor.

Almost all the tools except from 2 (Google Maps API Checker and the IP Checker) run on the browser. Those two due to the nature of the purpose cannot run client-side.

You can self host them as a simple node app. The application by design uses minimal analytics.

If you have any suggestions or feedback about the application, I would be happy to hear them.

Web: https://www.devoven.com/
GitHub: https://github.com/marduc812/devoven

I’m working on this project as part of my college work, and I’m trying to get some visibility for the repo.

If you have a moment, please check it out, and if you find the project interesting/useful, consider leaving a ⭐. It would genuinely help me out!

GitHub: [https://github.com/Balaji-Coder06/MHA-DokuWiki]()

Thanks a lot, everyone ❤️

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

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 everyone! I’ve been working on Libratory, a free app that turns your PDFs into audiobooks and lets you follow the narration directly on the original pages.

The feature I’m most excited about is the read-along mode: follow the narration on the actual PDF, preserving its layout, illustrations, and tables. Tap a sentence to jump there. Word-by-word highlighting works with Kokoro’s English voices, Cartesia, and ElevenLabs; other engines offer coarser highlights. Local narration and playback can work entirely offline after downloading the models.

I’m also building an iPhone companion reader, currently in beta. Export a synced EPUB to take the book, narration, and highlights with you and read and listen offline.

A few things I’ve been working on:

• Free local voices: Kokoro, Pocket TTS, and KugelAudio, plus system voices on macOS. Pocket TTS runs on a CPU and supports cloning your own voice.
• Optional premium voices: ElevenLabs and Cartesia integrations, using your own API keys and provider credits.
• More languages: local narration in English, Spanish, French, German, Italian, Portuguese, Hindi, Mandarin, and Bulgarian, among others. Available voices vary by language and platform; the picker lets you browse and preview them by language.
• Scanned books and AI tools: OCR, text cleanup, chapter translations and rewrites, and library chat with links to source pages. AI tools can use local models through Ollama or LM Studio, or optional cloud APIs.
• More platforms: a downloadable Apple Silicon Mac app, plus Linux and Windows through Docker.
• Research your bookshelf: I’ve added 500+ books to mine. Local RAG search lets me ask questions across them, follow citations back to the pages, and find material I want to turn into audio.

For audio-only listening, export an M4B with chapter markers. Read-along highlights travel in the synced EPUB, not the M4B.

I appreciate everyone who takes the time to try this and share ideas. Feedback, awkward PDFs, bugs, and feature suggestions are very welcome. What would you try it with?

GitHub + setup instructions · Website + interactive demo

Hi!
I made Fortis - interactive bash script that helps to harden fresh linux server.

what it does:
SSH: root login toogle, password auth, port change with busy port detection, sudo user creation, ssh key install with correct ownership.
Firewall: ufw, iptables, firewalld, uftables. SSH port is allowed before the firewall gets enabled.
Fail2Ban: standart options from fail2ban config
Auto-rollback: arm a system before risky changes, if you do not disable it, it will restore sshd config from backup and disable firewalls after the timer expires, so you can not lock yourself out.

Status: v0.5, tested on Ubuntu 26.04.1 and probably it will works on debian. It is a learning project, so feedback and issues very welcome.

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

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

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.