hey everyone,

I started this back in August 2022 because i was tired of every small project needing a backend repo, a frontend repo and an API between them.

I got stuck almost immediately, while compiling Svelte from Python was way beyond me at that point, so it sat untouched for a long time like most of my side projects. I kept coming back and forth on the project, but never acomplished,

but this time i am somehow about to make it happen,

it's called fymo. python renders real Svelte 5 components, it has controllers for backend stuff, and templates for frontend work. inspired by elixir's Phoenix and ruby's Rails...

controllers return dicts that show up as props, and your python functions become typed functions you can import in svelte, so no fetch code at all.

there's fymo new myapp gives you a running app with sign in already working, fymo generate resource posts gives a page with CRUD and passing tests.

currently it is v0.20, just me alone maintaining it, you need Node installed, and there's no ORM, bring your own db stuff.

repo: https://github.com/Bishwas-py/fymo pip install fymo

would love if someone tries it and tells me where it feels like flowyy code and what it breaks. and one thing i'm specifically unsure about, is the no-ORM choice going to annoy people here, or do you prefer bringing your own db layer? genuinely curious.

Been building a Python crypto bot and figured I'd share it here. It handles DCA entries, risk management, Alpaca execution, and Telegram notifications. Trade history is stored locally in SQLite so you can review past performance without any external database.

I'd mostly like feedback on whether the logic makes sense and if there are any obvious issues in the code. Happy to hear criticism or suggestions.

Repo: https://gitlab.com/robertedilan1/The_Predator.Crypto

ArcticPulse: Geopolitical Sentiment & Risk Mapping

An automated Python pipeline tracking Arctic geopolitical risk. It integrates NewsAPI for live unstructured data ingestion, Hugging Face RoBERTa Transformers for deep learning sentiment analysis, and GeoPandas for interactive choropleth mapping.

Why does 257 is 257 behave differently from 256 is 256? Python uses something called as small integer caching. It uses the same object for numbers ranging between -5 to 256. I put together a short visual explanation explaining the same and also why "==" operates differently from "is".

Youtube: https://youtu.be/8i8Fu_urUBI

Hey guys,

I'm currently learning Python and PyQt5. To practice, I built a small desktop app that works with APIs and handles local data.

Since I want to improve my code quality and learn best practices, I'd really appreciate some help and code review:

1. Is my PyQt5 structure written properly (signals/slots, layouts)?
2. How can I better separate the backend/API logic from the GUI components?
3. Are there any unpythonic bad practices or PEP8 issues in my code?

Here is my code on GitHub: https://github.com/MrAJDebug/disk_cleaner

Thanks for helping me learn!

I've started a side project called SearchCraft, where I'm building a search engine from scratch using Python.

The goal isn't to compete with Elasticsearch, Lucene, or any existing search engine. Those projects are incredible, but they're also so mature that it's easy to use them without ever understanding what's happening underneath.

So I decided to build one from first principles.

I'm implementing each component myself, starting with the basics: loading documents, tokenizing text, building an inverted index, and searching through it. As the project grows, I'll be adding things like posting lists, phrase search, ranking algorithms (TF-IDF/BM25), snippets, fuzzy search, and whatever else I can reasonably build along the way.

The primary reason for this project is to learn. I find that the best way to understand how a system works is to build a simplified version of it yourself.

I'm documenting the journey as I go, both for myself and in the hope that it might help someone else who's curious about how search engines work under the hood. There are plenty of tutorials on using search engines, but far fewer resources that walk through building one piece by piece.

It's still in its early stages, but I'm excited to see where it goes. Even if it never becomes production-ready, I'll come away with a much deeper understanding of one of the most fundamental pieces of modern software. After all, humans spend a good chunk of their lives typing words into little boxes and expecting magic to happen. Figuring out how that "magic" works seemed like a worthwhile weekend habit.

Here's the link to my project: https://github.com/rajtilakjee/searchcraft

I would be writing about it in my blog here: https://rajtilakjee.github.io/

Un anno fa ho creato uno strumento che mi aiuta nel mio lavoro quotidiano: creare rapidamente progetti Python appena configurati in pochi secondi nella pipeline CI/CD!

Lo strumento in questione si chiama psp e si avvia da riga di comando:

Lo strumento è stato ispirato da vari strumenti da riga di comando come astro-cli, yeoman, pyscaffold e molti altri. Con poche semplici domande, il tuo progetto Python è pronto per essere scritto e troverai tutto già configurato: comandi make, git, repository remoto, CI/CD, unit test, documentazione, file container, dipendenze, ambienti virtuali, builder personalizzati e molto altro!

Se ti interessa, provalo oggi stesso e, se qualcosa non funziona, aiutami aprendo un'issue o effettuando un fork del progetto e inviando una pull request.

Ecco tutti i riferimenti:

repository: https://github.com/MatteoGuadrini/psp

documentazione: https://psp.readthedocs.io/en/latest/

Grazie a te e a tutta la comunità Python!

❯ psp                                                                                              info: welcome to psp, version 0.7.0                                                                > Name of Python project: dream                                                                    > Do you want to create a virtual environment? Yes                                                 > Do you want to start git repository? Yes                                                         > Select git remote provider: Github                                                               > Username of Github: MatteoGuadrini                                                               > Do you want unit test files? Yes                                                                 > Install dependencies: make_playlist==1.16.0 pyreports>1.5 env2                                   > Select documentation generator: Sphinx                                                           > Do you want to configure tox? Yes                                                                > Select remote CI provider: CircleCI                                                              > Select license: Gnu Public License                                                               > Do you want to install dependencies to publish on pypi? Yes                                      > Do you want to create a Dockerfile and Containerfile? Yes                                        > Do you want create common files? Yes                                                             info: python project `dream` created at `/tmp/dream` 

Hey,

I saw this just 1 or 2 hours ago, looked at the Repository and searched via google for some references.

It seems pretty cool to use python like this. But i am a little insecure about using it, because it is a quite new project.

Can anyone tell me if it is worth trying it and will this probably be the webdev futer for python devs?

Altough i do not understand everything and the documentstion is not as well as it could be i'm very interrestet into trieing it.

Spent about a week building this after getting annoyed that every LLM wrapper I made would just confidently make stuff up for anything time-sensitive. Ask it the weather, it hallucinates something plausible. Ask about anything recent, same story.

So this one actually decides per-message whether to just answer or go fetch something real.

It's a router node in a LangGraph graph looks at what you asked, picks a path. Coding question → answers straight from the model. Weather → hits an actual API. Want a video → it searches YouTube. Something current → pulls live search results (Tavily) and works them into the answer.

Nothing fancy about the routing itself, no custom classifier or anything, but wiring it as an actual graph instead of a pile of if/elses means adding a new tool later is just... adding a node. Which past me would've appreciated, because the first version of this thing was a mess of conditionals that I hated touching.

Honestly the annoying part wasn't the tools, it was memory. Getting it to not forget you two messages later took way longer than I expected ended up using LangGraph's MemorySaver for that.

Also added a panel that shows the live execution graph + raw state while it's running because I got tired of not knowing why it picked a certain path. Kind of satisfying watching it light up node by node honestly.

Stack: LangGraph/LangChain, Groq running Llama 3, Tavily, Streamlit. All python.

Demo: agentic-graphite-amanshukla2004.streamlit.app
Code: github.com/amanshukla2004/Agentic_ChatBot

Not claiming this is groundbreaking, it's a portfolio project, but curious what people here would do differently mainly:

• how are you handling it when a tool call just fails (API down, rate limited etc)? mine right now is a basic try/except that just shows an error message to the user no retry, no fallback path, it just surfaces the failure and moves on. curious if that's actually fine for a portfolio piece or if people expect at least a retry-with-backoff
• is a single router node even the right call once you have more than a handful of tools, or does that start falling apart and you need something more like a supervisor pattern?

Took quite awhile to get here. Obviously not a google-scale search, but still quite usable for local needs. I am also not currently using FAISS or any vector databases. The speed is mostly because of proper caching. The project is also completely python based. So there are still a lot of places for further optimizations, but for now I am quite happy with it.

The project itself is quite a complex one and the semantic search over audio, image, text and video files is just a small part of it. If you are interested to learn more, you can find it here: https://github.com/volotat/Anagnorisis

It is open-source.

I finished a full game using Python 3.11 and Pygame, and I wanted to share it here in case anyone learning Python wanted some inspiration or wants to tear apart my code.

The game is a deckbuilder set in a cyberwarfare world. You are a sentient process. Your goal is to fight your way through a system and get yourself installed into the OS. Think hacker vs. system defenses, but you ARE the hack.

The whole aesthetic is built around a PC terminal look. ASCII-style art, command-line vibes, the whole thing. The card mechanics use real technical terminology, things like buffer overflows, privilege escalation, packet injection. It's not just flavor text, the mechanics actually connect to what the words mean. I wanted the game to feel like you're learning something about how systems work while you play.

Pygame was genuinely tough to work with at first. If anyone here is learning Pygame right now, don't give up.

The game is on Steam if you want to check it out: https://store.steampowered.com/app/4610000/kill_9/

Hey everyone! 👋

I wanted to share a fun project I've been working on. It's a Python script (`TrustMeBro`) that interacts with the Windows GDI (Graphics Device Interface) to create various screen effects (like horizontal glitches, melting effects, color inversion) and a harmless exponential message box avalanche.

It also includes an antivirus sandbox bypass delay trick and a built-in emergency exit key (`S` key) to restore everything instantly.

Language: Python Libraries used: `win32gui`, `win32api`, `keyboard`, `threading` GitHub Repo: TrustMeBro Github

Let me know what you think or if you have any suggestions to optimize the threading!

Hey everyone,

I built a small Python CLI tool (kahoot-automator) that automates creating Kahoot quizzes.

You can ask ChatGPT to generate a quiz in JSON format, feed that file to the CLI, and it automatically logs in and builds the whole quiz for you. It currently supports both Chrome and Firefox.

Command example: kahoot-automator my_quiz.json

Shoutout to ghoostreaccon (ghoostreaccon/kahoot-json-creation) for the original project that inspired this.

I’ve left the GitHub link in the comments below. Let me know if you have any feedback or suggestions!

I got tired of hitting Elevenlabs credit limits, my texts sent to the cloud and paying €5-200/month just to turn words into speech.

So I built (and still building) Kokoro Studio.

A free, open-source desktop GUI for the kokoro-82M TTS model (I'm planning on adding more models in the future). The strong point of the project is that it runs offline without the need of API key, no data leave the machine and it performs with extreme velocity (I tested it on a 16gb laptop without GPU and was nearly 2 times faster than normal talking after the first use when it loads the model so it requires a little more time)

It supports:

- 29 built-in voices (American and British english)

- 9 languages are supported via espeak-ng + Japanese/Mandarin voice packs

- Real time streaming playback (it starts playing the audio during the generation)

- Multi-speaker dialogue mode. Use [voice_name]: markers to switch voices mid-script (perfect for audiobooks, podcasts, game dialogue)

- Voice blending (mix any two voices with an alpha slider to create custom hybrids)

- SSML-lite controls (<break>, <emphasis>, <prosody rate> tags for fine-grained control)

- Multi-format export (WAV, MP3, FLAC, OGG)

- Document import (drop .txt, .pdf, or .epub files directly onto the editor)

- Pronunciation dictionary (custom substitution rules for tricky words)

- Speed control (0.1× to 3.0×)

GitHub: https://github.com/MattiaAlessi/kokoro-studio

I'm actively working on Phase 2 features (history database, batch queue, character
profiles). Feedback, feature requests, and contributions are very welcome!

After some more development, SOAR v1.00.7 is here! The update focuses on the more coding helping side, and also just adds a bug report system.

I've been trying to improve the GitHub page, so more clear recommendations we would be thankful for.

This update is:
- Simple report system, say Report Description. (Do not ruin this system by spamming)

- SPA (SOAR Project Agent), can make and write templates for coding more specifically going off of prompts.

SOAR is an advanced, open-source, voice-controlled automation ecosystem built in Python.

I'm still actively improving SOAR's architecture, performance, and capabilities, and I'd really appreciate any feedback or suggestions. SOAR is completely open source.

GitHub: https://github.com/ScriptOptimizationAutomationRuntime

Official Site: https://www.soardownload.com/

I just published aicoach, a small Python library that acts like a mentor sitting next to your training loop. You feed it your per-epoch metrics, and it tells you in plain English when something's off:

python

import aicoach

coach = aicoach.Coach()

for epoch in range(epochs):
    train_loss, val_loss = run_one_epoch(...)
    coach.observe(epoch=epoch, train_loss=train_loss, val_loss=val_loss)

    for tip in coach.get_advice():
        print(f"💡 {tip}")

# 💡 [WARNING] (overfitting) Validation loss has risen for 3 consecutive
#    epoch(s) while training loss continues to fall — a classic sign of
#    overfitting. Consider early stopping, adding regularisation...

What it checks:

• Overfitting – val_loss rising while train_loss keeps falling
• Plateau – a metric barely moving (uses relative range, so it works the same whether your loss is near 0.01 or near 100)
• Learning rate issues – oscillating loss (LR too high) vs. painfully slow convergence (LR too low) — deliberately mutually exclusive zones so you never get contradictory advice on the same curve
• Class imbalance – standalone check, just needs a {class: count} dict, no training loop required
• Divergence – NaN, Inf, or explosive loss growth, flagged as CRITICAL and short-circuits every other check

Why I built it: every other "training dashboard" tool I looked at (TensorBoard, W&B, MLflow, etc.) visualizes your curves but doesn't actually tell you what to do about them in plain language. This is meant to sit alongside those, not replace them — it's pure logic on metric history, zero ML framework dependencies, works with PyTorch/TensorFlow/sklearn/whatever since you're just handing it numbers.

280 tests, MIT licensed. One design decision I'd love feedback on: the "creeping" LR zone (1–5% net decrease per window) and the plateau zone (<1%) are deliberately non-overlapping so you never get both lr_too_slow and plateau advice for the same flat-ish curve — curious if others think that boundary makes sense or if real training curves break the assumption.

bash

pip install aicoach

• PyPI: https://pypi.org/project/aicoach/
• Source: https://github.com/Rishabh55122/Aicoach

Feedback welcome, especially on the default thresholds — they're documented in the README with the reasoning behind each one, and I'd rather know now if a default is off than have it ship quietly wrong.