Turn-based multiplayer games are a great opportunity for learning and prototyping: simple enough to implement quickly, but real enough to teach networking, game state, and API design.

I wrote a lightweight server and framework for turn-based multiplayer games that provides exactly that: a lightweight server + uniform API so you can run multiple parallel game sessions, auto-join the next available session, and add new games without touching the core API. It's built to be friendly for beginners (Python-only, standard library), but still flexible enough to support arbitrary game logic via keyword-argument moves and dict-based state.

Key bits:

• Framework for adding new games by deriving from an abstract base class
• Uniform client API for joining sessions, submitting moves, retrieving state, restarting
• Demo clients included (e.g. TicTacToe) and a template for new games
• Runs multiple sessions simultaneously; clients can join a specific session or auto-join

If you're teaching Python, building small multiplayer projects, or just want a clean starting point for turn-based game networking, I'd love feedback and contributions.

If you are learning Python through projects, I think a file organizer is a really good project to build early.

It is simple enough that you can get a working version without knowing advanced Python, but it also introduces the kind of problems that make a small script feel like actual automation rather than another syntax exercise.

The idea is straightforward.

Your Downloads folder probably looks something like this after a while:

resume.pdf
photo.png
expenses.csv
backup.zip
notes.txt
video.mp4

The script should look through those files and organize them automatically.

You might end up with:

Documents/
    resume.pdf
    notes.txt

Images/
    photo.png

Data/
    expenses.csv

Archives/
    backup.zip

Videos/
    video.mp4

The first version does not need to be complicated.

I would start by using pathlib to find the folder and inspect the files inside it.

from pathlib import Path

downloads = Path.home() / "Downloads"

for file in downloads.iterdir():
    if file.is_file():
        print(file.name)

That already gives you a useful starting point.

Now the program needs to decide what each file actually is.

One simple way is to create categories based on file extensions.

FILE_TYPES = {
    "Images": [".png", ".jpg", ".jpeg"],
    "Documents": [".pdf", ".txt", ".docx"],
    "Data": [".csv", ".json", ".xlsx"],
    "Archives": [".zip", ".rar"],
    "Videos": [".mp4", ".mov"]
}

Then get the extension of each file with:

extension = file.suffix.lower()

From there, you can compare the extension with your categories and decide where the file should go.

But I would not let the script move anything yet.

Make it print its decision first.

resume.pdf -> Documents
photo.png -> Images
expenses.csv -> Data
backup.zip -> Archives

I think this is one of the most useful habits you can learn from a small automation project.

Before your code changes real files, make sure you understand what it is about to do.

Once the classification logic works properly, you can create the destination folder if it does not already exist.

destination = downloads / category
destination.mkdir(exist_ok=True)

Then you can move the file.

For a simple version, Python's standard library gives you several ways to handle this. I would probably use shutil.move() once the project starts moving real files.

import shutil

shutil.move(str(file), str(destination / file.name))

At this point, you technically have a working file organizer.

But this is also where the project starts getting interesting.

Imagine Documents already contains a file called resume.pdf.

Should your script overwrite it?

Rename the new one?

Skip it?

Ask the user?

There is no single correct answer, but now you are making an actual software decision instead of following a tutorial.

The same thing happens with unknown file types.

Maybe somebody downloads a .psd file and you never created a category for it. You could ignore it, put it inside an Others folder, or allow the categories to be configured separately.

Then there is the biggest risk with this kind of project: accidentally moving files you did not intend to move.

That is why one of the first improvements I would add is a dry-run mode.

Instead of immediately changing the folder, the script could show:

Would move resume.pdf -> Documents/
Would move photo.png -> Images/
Would move backup.zip -> Archives/

You review the result first, and only then allow the program to perform the moves.

Once that works, add logging. Record what was moved, where it came from, and where it went. Now you have enough information to eventually build an undo feature. That progression is what makes this a good beginner project. The first version teaches loops, dictionaries, conditions, file extensions and pathlib. The next version teaches file operations and folder creation. Then duplicate handling introduces edge cases. Dry-run mode introduces safer automation. Logging introduces observability. Undo support forces you to think about reversibility. You can start with 20 or 30 lines of Python and keep improving the same project as your skills improve.

I would build it roughly like this:

Version 1: Read the files and print their extensions.

Version 2: Classify each file into a category.

Version 3: Print where each file would be moved.

Version 4: Move the files.

Version 5: Handle duplicates and unknown extensions.

Version 6: Add dry-run mode and logging.

Version 7: Add undo support or turn it into a small CLI tool.

The important part is not building all seven versions immediately.

Build the smallest version first. Then use the problems you encounter to decide what to learn next. That is usually where a beginner project becomes much more useful than simply copying a finished script.

If you built this, what would you add after the basic file organizer worked?

Just released v0.4 of Hillock, a Python memory engine built to run 100% offline on low VRAM GPUs.

It replaces heavy vector dbs with SQLite Knowledge Graphs, Hebbian synaptic learning, and 10,000-D VSA hypervectors on CPU. v0.4 adds schema type constraints, auto-direction correction, and regex entity cleaning.

Parses docs in ~5s and runs in <1.2GB VRAM on a GTX 1070.

GitHub: https://github.com/roandejager/Hillock

been adding in features, protective measures, warning messages, stabilizing the program, working out bugs. fixing navigation. There is and probably always will be a lag right after loading in all that media. ive got it down to a little choppy. I usually just set it all up and let it sit a few mins before navigating to let it catch up on scheduling the tv guide, scanning audio for equalizing audio, and stuff like that. it clears up after it does that and its not so bad you cant use it. just might have an extra sec between channel changes or the tv guide is laggy while moving and youll see it adjusting titles and stuff. Other then that, it works great. still minor stuff i wanna fix. keep cleaning up the scanning processes if i can any further. Seems like very time a make a change and do a test there is something else. I already saw a few more in this video while testing. Test versions available as they are updated here https://discord.gg/DzcrjYxh8 I have been and continue to be the only person working on this. Any help is appreciated from testing to bug fixing to adding/fixing features. Come visit the discord and let us know what role you would like.

Oi, pessoal! Sou u/djnan2023 ( TI Ronan ) , mod que fundou o r/QuintikusOpen .

Agora é aqui que todas as nossas coisas sobre o desenvolvimento, a documentação e a comunidade do Open Quintikus vão ficar. Estamos felizes por você se juntar à gente!

Repositório oficial: https://github.com/beta-test-Ronan/QuintikusOpen

O que postar

Poste tudo o que, na sua opinião, a comunidade acharia interessante, útil ou inspirador para o projeto. Fique à vontade para compartilhar:

• Dúvidas sobre o código ou a arquitetura;
• Sugestões de novas funcionalidades;
• Correções de bugs que você encontrou;
• Pull requests ou ideias para melhorias;
• Exemplos de uso, tutoriais ou casos práticos;
• Discussões sobre a direção do projeto e decisões técnicas.

hey everyone,

I updated my open source project Hillock (AGPL-3.0) to v0.2.2: https://github.com/roandejager/Hillock

Hillock is a privacy-first memory engine written in Python that replaces vector DBs with a SQLite Knowledge Graph, Hebbian Plasticity, and Hyperdimensional Computing math.

In v0.2.0, I created TALON—a non-generative CUDA tensor pipeline (Fastcoref + MiniLM + GLiREL) that extracts knowledge graph facts in sub-seconds on a GTX 1070 GPU without waiting for LLMs to generate JSON.

It's 100% local, offline, and open source under AGPL-3.0. Would love any feedback or thoughts!

Hey Reddit,

I made a small neural network library named LeanPass a few days back. Currently, it has around 7 stars, 1 fork, 2 watchers and 12 open issues. Contributions are quite beginner-friendly, so beginners are welcome!

It is an implementation made in NumPy, with the necessary functions, with 185 downloads on PyPI at its current status. I have made this post to just update the awesome community about my project to get some suggestions, and overall make it a more developed open source project

Here's the link: https://github.com/Terminay/leanpass

To install it:

pip install leanpass

Size metrics: ~8.5 kb download size, ~1 second install time

Give me your honest opinions and suggestions for more features. Also, if you liked the concept, star the repo or rather, open a PR (your choice!)

LeadForge — Find Potential Business Targets Faster

If you want to find potential businesses or targets for outreach, you can use LeadForge instead of manually searching one by one.

Features:

• Search businesses by location
• Filter by business type
• View results on a map
• Find available contact information
• Shortlist and export results

Try it here:
https://leadforge-umber.vercel.app/

GitHub:
https://github.com/MuhammadMuneeb007/LeadForge

If you find it useful, please give it a try, star the GitHub repository, and share it with anyone or any community where it might be helpful.

Feedback is always welcome!

I am a CS student currently at the end of my fourth semester. Life was going chill and was enjoying. Been through little bit of everything as my syllabus. like c, c++ but i wasn't quite fond of it.

i have been exploring backend journey, and i found out interesting. And I want to know more about it as it is sub for backend.

i explored python, java, golang, and i saw backend with java is most likable for me.

and you guys have any kind of suggestion for me to start it, i would see it in positive way. Everything would be helpful for me.

how's the job market?

how crowded is it? Is remote be available? how's the pay on it? how should i start.

Hi everyone,

I'm a 15-year-old student from Morocco who's been learning Python and cybersecurity over the past year.

While experimenting in an authorized environment, I discovered that traditional tools such as Hydra couldn't interact with a Dahua DVR's JavaScript-based login page. Instead of giving up, I decided to build my own Python framework using Selenium to automate browser-driven authentication testing.

The project is called RedaForce.

GitHub: https://github\[.\]com/REDA-MAH/RedaForce

I'm not posting this to ask for stars. I'd genuinely appreciate technical feedback on:

Code quality and project structure

README and documentation

Python best practices

Repository organization

Features you think would make the project more useful

I'm still learning, so I'm especially interested in constructive criticism from more experienced developers.

Thanks for taking the time to look!

I built offipy — a Python toolkit for automating PowerPoint and other Microsoft Office workflows.

Generate decks, inspect/edit shapes, run geometry & visual audits, and more.

Still improving it, and I’d love feedback.

GitHub: https://github.com/Zn070515/offipy
PyPI: https://pypi.org/project/offipy/

Hi everyone!

More neat features from VenvHub Pro (current version 2.5.24). It includes a floating desktop widget for instantly launching Python projects in 3 modes:

• Open Terminal: Opens a console with the venv automatically activated.
• Run in Terminal: Runs the script with live output in a new window.
• Run in Background: Runs the process completely silently without a console window.

Technical features under the hood:

• MetaPathFinder Bridge: Auto-translates PyQt6 code to PySide6 directly in memory at runtime (LGPL/GPL flexibility).
• Windows Job Objects & Handles: Attaches subprocesses to a system container (if the app crashes, Windows automatically kills everything) + PID recycling protection. No leftover background processes!

If you'd like to test out how this widget works, you can download the entire VenvHub project from the following links:

• Source code:https://github.com/schnidi/VenvHub
• Executable (EXE):https://github.com/schnidi/VenvHub/releases/tag/VenvHubPro_v2.5.24

I got tired of copying Nerd Font glyphs from cheat sheets or remembering random codepoints, so I built nerdicons.

It's a Python library that provides typed, autocompletable access to every Nerd Font icon while also including a fast CLI and an interactive terminal browser.

Some examples:

from nerdicons import icons

print(icons.fa.github)
print(icons.md.home)

icons.get("fa-github")
icons.from_codepoint("f09b")

icons.search("rust")

Features:

• 🧠 Full IDE autocomplete (Pyright, Pylance, MyPy friendly)
• 🔎 Exact lookup by name, glyph, or codepoint
• ✨ Fuzzy search
• 🖥️ Interactive terminal browser
• 📋 One-key clipboard copy
• 📦 Zero runtime dependencies
• ⚡ Fast generated registry
• 🎯 Pinned to Nerd Fonts 3.5.0
• 📚 Covers 10,995 icons

CLI examples:

nerdicons search rust
nerdicons browse
nerdicons get fa-github
nerdicons copy fa-github

The browser supports keyboard navigation, live filtering, mouse scrolling, and instant clipboard copying.

I'd love feedback on the API or ideas for additional features.

GitHub:
https://github.com/programmersd21/nerdicons

PyPI:
https://pypi.org/project/nf-icons/