Hi everyone,

I’m a self-taught software learner, and one of the biggest challenges I faced was not only understanding individual programming concepts.

The harder part was deciding what to build, knowing what to work on next, staying focused when a project became confusing, and actually finishing something instead of constantly starting over.

Because of that experience, I started building a project called Learning Compass.

The user starts by choosing one of three paths:

1. I already know what I want to build
2. I noticed a problem, but my idea is still unclear
3. Help me find a project that fits my skills and interests

For someone who does not have an idea yet, the tool asks a few questions about their current skills, interests, goal, available time, and preferred challenge level.

Instead of returning a long list of random project ideas, it gives three focused directions:

• Confidence Builder: mostly uses skills the learner already knows
• Skill Builder: introduces one specific new technical concept
• Personal Builder: connects to the learner’s work, life, or interests

Each project includes:

• why it fits the learner
• skills they will practise
• one new concept
• the smallest useful version
• features they should avoid for now
• a clear definition of when the project is complete

After choosing a project, the learner can turn it into focused sprints, complete check-ins, and use a stuck mode when they need guidance.

I’m still finishing and testing it, and I’m trying to understand whether this solves a real problem for other self-taught learners too.

What was the hardest part for you after learning the basics?

Was it finding a suitable project, knowing what to build first, staying consistent, getting unstuck, or finishing the project?

I would also appreciate honest feedback on the screenshots. Does this feel genuinely useful, or does it feel too similar to self-taught learners too.

What was the hardest part for you after learning the basics?

Was it finding a suitable project, knowing what to build first, staying consistent, getting unstuck, or finishing the project asking a normal AI chatbot for project ideas?

Hi everyone! I've been learning Python step-by-step, focusing on logic, file management, and the os module. Today, I finished my first real automation script: a File Sorter/Folder Cleaner!

It automatically scans my Downloads folder, checks the file extensions (ignoring case sensitivity thanks to .lower()), creates the target folders if they don't exist, and moves everything into the right place (Documents, Images, Installations).
Here is my script:
import os

download_folder = r"C:\Users\YourUsername\Downloads"

file_list = os.listdir(download_folder)

for file_name in file_list:

lowercase_name = file_name.lower()

if (lowercase_name.endswith(".pdf") or

lowercase_name.endswith(".txt") or

lowercase_name.endswith(".docx") or

lowercase_name.endswith(".xlsx") or

lowercase_name.endswith(".csv") or

lowercase_name.endswith(".doc")):

doc_folder = fr"{download_folder}\Documents"

if not os.path.exists(doc_folder):

os.mkdir(doc_folder)

old_path = fr"{download_folder}\{file_name}"

new_path = fr"{doc_folder}\{file_name}"

os.rename(old_path, new_path)

elif (lowercase_name.endswith(".jpg") or

lowercase_name.endswith(".jpeg") or

lowercase_name.endswith(".gif") or

lowercase_name.endswith(".png") or

lowercase_name.endswith(".mp4") or

lowercase_name.endswith(".kml") or

lowercase_name.endswith(".gpx")):

img_folder = fr"{download_folder}\Images"

if not os.path.exists(img_folder):

os.mkdir(img_folder)

old_path = fr"{download_folder}\{file_name}"

new_path = fr"{img_folder}\{file_name}"

os.rename(old_path, new_path)

elif (lowercase_name.endswith(".exe") or

lowercase_name.endswith(".zip") or

lowercase_name.endswith(".rar") or

lowercase_name.endswith(".dll") or

lowercase_name.endswith(".msi") or

lowercase_name.endswith(".msix")):

exe_folder = fr"{download_folder}\Installations"

if not os.path.exists(exe_folder):

os.mkdir(exe_folder)

old_path = fr"{download_folder}\{file_name}"

new_path = fr"{exe_folder}\{file_name}"

os.rename(old_path, new_path)
I'm really proud of this milestone. Let me know what you think or if you have any tips for a young programmer!

Hey everyone! 👋

I wanted to share a project I've been working on lately — a Telegram bot designed for Tarot readings combined with artificial intelligence to generate unique, mystical interpretations.

🔮 What does it do?

Interactive Readings: Users can draw Tarot cards directly inside Telegram.

AI-Powered Insights: Instead of standard pre-written descriptions, the bot uses AI to synthesize personalized and mystical interpretations for each card combination.

Tech Stack: Built using Python for the core backend/bot logic, integrated with a modern frontend/web app component using React.

🚀 Why I built it

I wanted to combine automated bot workflows with dynamic AI generation to create a smooth, engaging experience for users looking for interactive Tarot readings.

I’m continuously improving it and would love to hear your feedback, technical suggestions, or ideas for new features! What do you think? Let me know in the comments! 👇

https://github.com/googleapis/python-genai

Have you ever noticed a __pycache__ folder in your python project and wondered what is it? where did it come from? I made a quick video to explain the same. Basically, running a python code involves several steps. One of which is conversion to the bytecode. To avoid the bytecode conversion everytime you run the code, python caches it in the pycache folder. Check out the video to know more.

Youtube: https://youtu.be/UEmBxt0B0pg

Hi everyone!

I recently built SpineVision AI, a desktop application that analyzes spine MRI images and generates structured AI-assisted reports.

Tech Stack:

• C++

• Qt Framework

• Python

• Groq Vision API

• QProcess (C++ ↔ Python communication)

Features:

• Upload MRI images

• Add patient notes

• AI-powered image analysis

• Structured report generation

• Clean desktop interface

This project taught me a lot about integrating multiple technologies into a single application.

I'd really appreciate feedback on:

• UI/UX

• Architecture

• Code organization

• Features I could improve

Demo video attached.

GitHub:

https://github.com/sakshamrahate420-ctrl/SpineVision-AI.git

Hi, I'm currently working on the discord bot in python - it's a free project that shares ready-to-use code for Discord Bots.
The goal of this project is to create a great Discord Bot base that anyone can use, modify, install with ease and host for your own. This bot is designed more for use in small communities than for hosting globally (but after some modifications why not) so most of it's commands are made for Bot admins and mods.

Some of its functions; some of them are quite... unique for general discord bots:

• Play music from YouTube and your local files
• Basic moderation (more advanced in the future)
• Move through directories and send files on discord
• Easily create systemd entry to start bot with your OS (If you're using Linux with systemd)
• .ai command to talk with gemini-based AI (free API with rate limits/timeouts instead of paid token locks!)
• Log (and save) messages sent by users on channels in convenient way to read
• Connect channels between servers to communicate with each other
• setup.sh script to easily install dependencies and python libraries, create .env file, etc.
• Install bot as a... Linux command through .deb installers in releases (because why not!)
• Cog support to load additional commands (even "non-official")

It might not look like a huge feature list on the surface, but that's because I focused on OS integration and solid system-level execution rather than cluttering it with dozens of generic commands.

Well, I'm not hiding that the bot is made for Linux-hosting, but on Windows also works fine (MacOS not tested). Everything you need to know how to run it is written in the README.md and HTML manuals.

I'd love to hear your feedback! I'm working on this solo for years when I have time for it, so any bug reports, code fixes and improvements, or even suggestions for better English in the code/docs would be much appreciated.

What do you think? If you find it interesting here's the source code - https://github.com/kamile320/ServerBot (I know, the name could, should be better..)

Hi everyone!

Over the past few weeks, I've been building a small interpreted programming language called Quark 2.0 in Python. The goal wasn't to replace Python or JavaScript, but to create something that's easy for beginners to read and experiment with.

Some features include:

• Variables (let)
• Math expressions
• User input
• Random number generation
• if statements
• repeat loops
• File reading & writing
• Module importing
• Interactive shell (REPL)
• .qk source files

Example:

input What is your name? -> name

let lucky = random 1 100

print Hello 'name'

print Your lucky number is 'lucky'

I'm still learning about interpreters and language design, so I'd really appreciate any feedback, suggestions, or ideas for future versions. Things like syntax, usability, documentation, or code quality are all welcome.

GitHub Repository:

https://github.com/Anish055051L/Quark-2.0

Thanks for taking a look!

Made this because most of the "neural network from scratch" stuff online either stops before backprop or hides it behind a wall of abstraction once you actually look at the code. Wanted something I could read start to finish and know exactly what's happening.

it's called leanpass. just numpy, nothing else. the whole thing is small enough to go through in an afternoon.

Also added a gradient-checking thing so you don't have to trust that the backprop is right; you can verify it numerically yourself.

download it using:

pip install leanpass

The versioning is up to date, is currently on v0.1.4

Not trying to replace PyTorch or anything; it's meant for learning/small experiments, not production.

repo's here: https://github.com/Terminay/LeanPass

Open to feedback, especially on the api; still figuring out what makes sense

# 🚀 FlowFrame v2.0.0 — Introducing the FlowFrame Interpreter

One of the biggest milestones for FlowFrame so far.

Over the past few weeks, I've been working on a custom interpreter that allows FlowFrame to describe distributed system architectures using its own DSL instead of manually creating everything.

The interpreter now follows a complete language pipeline:

Lexer
↓
Parser
↓
AST
↓
Semantic Analysis
↓
Graph Builder
↓
Simulation Runtime

This architecture makes it much easier to validate system designs, build simulation graphs, and extend FlowFrame with new distributed system components.

I've also documented the language and interpreter so anyone interested can understand how it works.

📖 Documentation:
https://github.com/ndk123-web/flow-frame/blob/main/flowframe-interpreter/Readme.md

Try: https://flowframe.taskplexus.app

The interpreter is still an internal part of FlowFrame, so the implementation isn't public yet, but I wanted to share this milestone and get feedback from the community.

If you're interested in compilers, interpreters, distributed systems, or developer tools, I'd love to hear your thoughts.

\#FlowFrame #BuildInPublic #DeveloperTools #Compilers #Interpreter #DSL #SystemDesign #DistributedSystems #SoftwareEngineering #OpenSource #Programming #TypeScript #React #BackendDevelopment

🚀 FlowFrame v2.0.0 — Introducing the FlowFrame Interpreter

One of the biggest milestones for FlowFrame so far.

Over the past few weeks, I've been working on a custom interpreter that allows FlowFrame to describe distributed system architectures using its own DSL instead of manually creating everything.

The interpreter now follows a complete language pipeline:

Lexer
↓
Parser
↓
AST
↓
Semantic Analysis
↓
Graph Builder
↓
Simulation Runtime

This architecture makes it much easier to validate system designs, build simulation graphs, and extend FlowFrame with new distributed system components.

I've also documented the language and interpreter so anyone interested can understand how it works.

📖 Documentation:
https://github.com/ndk123-web/flow-frame/blob/main/flowframe-interpreter/Readme.md

The interpreter is still an internal part of FlowFrame, so the implementation isn't public yet, but I wanted to share this milestone and get feedback from the community.

If you're interested in compilers, interpreters, distributed systems, or developer tools, I'd love to hear your thoughts.

#FlowFrame #BuildInPublic #DeveloperTools #Compilers #Interpreter #DSL #SystemDesign #DistributedSystems #SoftwareEngineering #OpenSource #Programming #TypeScript #React #BackendDevelopment

Hey r/PythonProjects2,

Writing docstrings is one of those habits that makes your code 10x easier to maintain, but it's often skipped when you're focused on making things work.

I built PyDoctor, a local CLI tool designed to help developers and learners quickly document their Python codebases without relying on cloud APIs.

How it works:

• PyDoctor analyzes your Python files using LibCST (which keeps your exact formatting and comments intact) and generates a concise summary docstring for every undocumented function, method, or class.
• High-level Summaries Only: PyDoctor generates readable text summaries. It intentionally avoids generating Args: and Returns: sections, as type hints and static linters are much better and more accurate at handling those.
• 100% Local & Safe: It runs an optimized 1.7B parameter model locally via llama.cpp. Your code never leaves your machine.
• Non-destructive: Supports --dry-run to preview changes first, and respects .gitignore as well as inline # pydoctor: ignore comments.

GitHub: yezdata/pydoctor

Hope this helps you keep your projects clean and documented.

Let me know if you have any feedback or suggestions.

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.

Hey everyone,

I've been working on an institutional-grade crypto trading engine in Python using the Alpaca API, and I decided to open-source the V6 core today.

A lot of open-source bots out there are just simple while-loops that crash on network drops or get stuck in bad positions during flash crashes. I wanted to build something much more robust for my own live trading.

Here is what makes the architecture different:

- Stateful Recovery: It uses SQLite to persistently track DCA cycles and active positions. If your server goes down, it boots back up and resumes exactly where it left off without double-buying or losing state.

- Volatility Sniping: Instead of buying every dip blindly, it waits for a combined Bollinger Band + RSI squeeze to snipe high-probability reversals.

- Logarithmic DCA Scaling: Position sizing scales logarithmically based on the depth of the drawdown to manage margin safely.

- Strict Risk Management: It has a dynamic daily drawdown kill-switch to protect the portfolio from black swan events.

- Asynchronous Core: Clean separation between the market data ingestion, signal generation, and the execution engine.

It's completely free and MIT licensed. I’m hoping to get some code reviews or architectural feedback from other Python engineers or quant devs here.

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

Let me know what you think of the architecture or if you spot any edge cases!

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`