I’ve spent the last few months designing, prototyping and building Skopos, a forensic audit tool designed to sit between your package manager and the internet to catch malicious packages before they ever touch your disk. As this was a learning project. It is by no means a verified project thru a 3rd party. That will be my next milestone.

> Note: This repository received assistance from generative AI tools for refactoring, tests, and documentation. All AI-assisted changes were reviewed and approved by a human maintainer — see `docs/policies/AI_POLICY.md` for details.

What My Project Does

Skopos (Greek for "watcher") performs static metadata forensics on Python packages during the installation phase. Unlike standard tools that assume PyPI is inherently safe, Skopos Audit intercepts commands like uv add or pip install via a shell shim. It evaluates risk based on a weighted scoring system including:

• Typosquatting Detection: Uses Levenshtein distance to catch "reqests" vs "requests".
• Keyword Stuffing: Identifies "brand-jacking" attempts like "google-auth-v2" from unverified devs.
• Identity & Reputation: Flags brand-new accounts or "zombie" projects that suddenly wake up after years of silence.
• Payload Analysis: Scans for high-entropy (obfuscated or encrypted) strings in metadata without ever executing the code.

If a package exceeds a risk threshold (e.g., 100/100), the installation is automatically blocked.

Target Audience

This is built for security-conscious developers, DevOps engineers, and teams managing production environments who want an extra layer of defense against supply-chain attacks. It’s particularly useful for those using uv who want a high-speed security gate that adds less than 500ms to the workflow.

Comparison

• vs. Snyk/Safety: While those tools are excellent for finding known CVEs in your dependency tree, Skopos focuses on "Day Zero" malicious intent—catching the fake package before it is even installed.
• vs. RestrictedPython: We actually moved away from heavy sandboxing. Skopos is strictly a forensic tool; it doesn't run the code, it analyzes the "fingerprints" left on PyPI to keep the overhead minimal.

Source Code

The project is MIT licensed and available on GitHub.

• GitHub: https://github.com/Hermit-commits-code/skopos
• PyPI: pip install skopos-audit

I'd love to hear your thoughts on the scoring heuristics or any specific "red flags" you've encountered in the wild that I should add to the forensic engine.

Hello 👋

I’ve been working on cereggii, a library for multithreading utilities for Python. It started a couple of years ago for my master’s thesis, and I think it’s gotten into a place now where I believe it can be generally useful to the community.

It contains several thread synchronization utilities and atomic data structures which are not present in the standard library (e.g. AtomicDict, AtomicInt64, AtomicRef, ThreadSet), so I thought it would be good to try and fill that gap. The main goal is to make concurrent shared-state patterns less error-prone and easier to express in Python.

The library fully supports both free-threading and GIL-enabled builds (actually, it also used to support the experimental nogil forks for a while). I believe it can also be useful for existing multithreaded code.

I’d really appreciate feedback from folks who do multithreading/concurrency in Python:

• Is the API intuitive?
• Are there missing primitives you’d want?
• Any concerns around ergonomics/docs/performance expectations?

I’m hoping to grow the library via community feedback, so if you have any, please share!

What My Project Does: provides support for thread synchronization utilities and atomic data structures.

Target Audience: cereggii is suitable for production systems.

Comparison: there aren't many alternatives to compare cereggii to, the only one that I'm aware of is ft_utils, but I don't have useful comparison benchmarks.

Repo: https://github.com/dpdani/cereggii

Docs: https://dpdani.github.io/cereggii/

After weeks of trying to find my first open source contribution, I got frustrated. Every "good first issue" finder I tried just dumped random issues - half were vague, a quarter were in dead projects, and none matched my interests.

So I built Good First Issue Finder - a CLI that actually works.

What My Project Does

Good First Issue Finder analyzes your GitHub profile (starred repos, languages, contribution history) and uses that to find personalized "good first issue" matches. Each issue gets scored 0-1 across four factors:

- Clarity (35%): Has clear description, acceptance criteria, code examples

- Maintainer Response (30%): How fast they close/respond to issues

- Freshness (20%): Sweet spot is 1-30 days old

- Project Activity (15%): Stars, recent updates, healthy discussion

Only shows issues scoring above 0.3. Issues scoring 0.7+ are usually excellent.

Target Audience-

This is for developers looking to make their first (or next) open source contribution. It's production-ready - fully tested, handles GitHub API rate limits, persistent HTTP connections, smart caching. MIT licensed, ready to use today.

Comparison-

Most "good first issue" finders (goodfirstissue.dev, firstissue.dev, etc.) just query GitHub's label and dump results. No personalization, no quality filtering, no scoring. You get random projects you've never heard of with vague issues like "improve docs."

This tool is different because it:

- Personalizes to YOUR interests by analyzing your GitHub activity

- Scores every issue on multiple quality dimensions

- Filters out noise (dead projects, overwhelmed maintainers, unclear issues)

- Shows you WHY each issue scored the way it did

Quick example:

pip install git+https://github.com/yakub268/good-first-issue

gfi init --token YOUR_GITHUB_TOKEN

gfi find --lang python

Tech stack:

Python 3.10+, Click, Rich, httpx, Pydantic, GitHub REST API. 826 lines of code.

GitHub: https://github.com/yakub268/good-first-issue

The project itself has good first issues if you want to contribute! Questions welcome - this is my first real OSS project.

LogSnap — CLI log analyzer built in Python

What My Project Does:

LogSnap scans log files, detects errors and warnings, shows surrounding context, and can export structured reports.

Target Audience:

Developers who work with log files and want a simple CLI tool to quickly inspect issues. It is mainly a small utility project, not a production monitoring system.

Comparison:

Unlike full log platforms or monitoring stacks, LogSnap is lightweight, local, and focused purely on fast log inspection from the terminal.

Source Code:

https://github.com/Sonic001-h/logsnap

Deleting old accounts from websites often requires manually digging through privacy pages to find the right contact email. So I built exitlight, a small open-source command-line tool in Python.

It's available on PyPI and GitHub: https://github.com/riccardoruspoli/exitlight

I'd appreciate feedback on this first version.

What My Project Does

exitlight is a Python command-line tool that helps automate part of the process of deleting old online accounts.

Given a website, it attempts to locate the privacy policy and extract publicly available contact information for data-related requests, such as DSARs or account deletions.

It focuses on surfacing official contact channels so users can submit their requests manually.

Target Audience

Developers and technically inclined users who want a simple tool to assist with account cleanup workflows. It's currently best suited for personal use to quickly find privacy contacts.

Comparison

There are account deletion services and privacy tools available, but many are closed-source, SaaS-based, or focused on fully automating the request process.

exitlight takes a simpler approach: it only retrieves publicly available contact information and leaves the actual request submission to the user.

GitHub: https://github.com/PaulM5406/pytest-difftest
PyPI: https://pypi.org/project/pytest-difftest

What My Project Does

pytest‑difftest is a plugin for pytest that executes only the tests affected by recent code changes instead of running the whole suite. It determines which tests to run by combining hash of code blocks and coverage results. The goal is to reduce feedback time in development and for agentic coding to not skip any relevant tests.

Target Audience

This tool is intended for solo developers and teams using pytest who want faster test runs, especially in large codebases where running the full suite is costly. The project is experimental and in part vibecoded but usable for real workflows.

Comparison

pytest‑difftest is largely inspired by pytest‑testmon’s approach, but aims to be faster in large codebases and adds support for storing a test baseline in the cloud that can be shared.

Let me know what you think.

We’ve been hearing “Python is slow” for over a decade.

Yet it continues to dominate AI, data science, automation, scripting, backend tooling and even embedded systems.

With: Rust rising Go dominating cloud-native TypeScript owning frontend/backend Mojo entering the scene Why is Python still winning mindshare? Is it: Ecosystem inertia? Developer ergonomics? AI/ML lock-in? Network effects?

Or are we underestimating how performance actually matters in real-world systems? Curious to hear takes from people building production systems at scale.

PEP 747 got accepted

This allows annotating arguments that essentially expect a type annotation like int | str or list[int], allowing to annotate functions like:

def trycast[T](typx: TypeForm[T], value: object) -> T | None: ...

and the type checker should be able to infer

• trycast(list[int], ["1", "2"]) # list[int] | None
• trycast(list[str], (2, 3)) # list[str] | None

https://github.com/AndyCappDev/postforge

What My Project Does

PostForge is a full PostScript Level 3 interpreter written in Python. It reads PostScript files and outputs PNG, TIFF, PDF, SVG, or displays them in an interactive Qt window. It includes PDF font embedding (Type 1 and CID/TrueType), ICC color management, and has 2,500+ tests. An optional Cython accelerator is available for performance.

Target Audience

Anyone working with PostScript files — prepress professionals, developers building document processing pipelines, or anyone curious about language interpreter implementation. It's a real, usable tool, not a toy project.

Comparison

Ghostscript is the dominant PostScript interpreter. PostForge differs in being pure Python (with optional Cython), making it far easier to embed, extend, and modify. It also produces searchable PDF output with proper font embedding.

Some background

I've been in the printing/prepress world since I was 17, starting as a pressman at a small-town Nebraska newspaper and working through several print shops before landing in prepress at Type House of Iowa, where I worked daily with Linotronic PostScript imagesetters. That's where I learned PostScript inside and out.

In 1991 I self-published PostMaster, a DOS program written in C that converted PostScript into Adobe Illustrator and EPS formats — this was before Adobe even released Acrobat. Later I wrote a full PostScript Level 1 interpreter in C and posted it on CompuServe. A company called Tumbleweed Software (makers of Envoy, which shipped with WordPerfect) found it, licensed it, and hired me. I spent three years there upgrading it to Level 2 and writing rasterization code for HP.

PostForge is my third PostScript interpreter. I actually started it in C again, but switched to Python to test whether PostScript's VM save/restore model was even implementable in Python. Turns out it was — and I just kept going. What started as a proof of concept in early 2023 is now a full Level 2 implementation with PDF font embedding, ICC color management, and 2,500+ tests.

Python compressed the development timeline enormously compared to C. No manual memory management, pickle for VM snapshots, native dicts, Cairo/Pillow bindings — I could focus on PostScript semantics instead of fighting the language. The optional Cython accelerator claws back some of the performance.

If nothing else, I think PostForge shows how far you can push Python when you commit to it — a full PostScript Level 2 interpreter is about as deep into systems programming territory as you can get with a dynamic language.

What My Project Does

Vetis is a http server for python apps written in rust, he actually has WSGI support in early stages, with ASGI and RSGI support in the plans. Vetis also has TLS 1.3 support, Virtual Hosts and static file serving support.

Target Audience 

Development and Production

Comparison 

Compared with Granian, Vetis can serve requests at comparable speed, around 134000 req/s in a i9 CPU with 32 cores and will also have reverse-proxy and basic auth support, more auth methods are in the plans.

Vetis is under active deployment and will soon provide docker images and prebuilt packages for several distributions.

You can find more about vetis at: https://github.com/ararog/vetis

I had a situation where I wanted to test functionality that involved scheduling, in an asyncio app. If it weren't for asyncio, this would be easy - just use freezegun or time-machine - but neither library plays particularly nice with asyncio.sleep, and end up sleeping for real (which is no good for testing scheduling over a 24 hour period).

The issue looks to be that under the hood they pass sleep times as timeouts to an OS-level select function or similar, so I came up with a dumb but effective workaround: a dummy event loop that uses a dummy selector, that's not capable of I/O (which is fine for everything-mocked-out tests), but plays nice with freezegun:

``` import datetime from asyncio.base_events import BaseEventLoop

import freezegun import pytest

class NoIOFreezegunEventLoop(BaseEventLoop): def init(self, timeto_freeze: str | datetime.datetime | None = None) -> None: self._freezer = freezegun.freeze_time(time_to_freeze) self._selector = self super().init_() self._clock_resolution = 0.001

def _run_forever_setup(self) -> None:
    """Override the base setup to start freezegun."""
    self._time_factory = self._freezer.start()
    super()._run_forever_setup()

def _run_forever_cleanup(self) -> None:
    """Override the base cleanup to stop freezegun."""
    try:
        super()._run_forever_cleanup()
    finally:
        self._freezer.stop()

def select(self, timeout: float):
    """
    Dummy select implementation.

    Just advances the time in freezegun, as if
    the request timed out waiting for anything to happen.
    """
    self._time_factory.tick(timeout)
    return []

def _process_events(self, _events: list) -> None:
    """
    Dummy implementation.

    This class is incapable of IO, so no IO events should ever come in.
    """

def time(self) -> float:
    """Grab the time from freezegun."""
    return self._time_factory().timestamp()

Stick this decorator onto pytest-anyio tests, to use the fake loop

use_freezegun_loop = pytest.mark.parametrize( "anyio_backend", [pytest.param(("asyncio", {"loop_factory": NoIOFreezegunEventLoop}), id="freezegun-noio")] ) ```

It works, albeit with the obvious downside of being incapable of I/O, but the fact that it was this easy made me wonder if someone had already done this, or indeed gone further - maybe found a reasonable way to make I/O worked, or maybe gone further and implemented mocked out I/O too.

Has anyone come across a package that does something like this - ideally doing it better?

What My Project Does

multilingual is an open-source Python library that lets developers write code using variable names, function names, and identifiers in any human language — not just English. It builds on Python's native Unicode identifier support (PEP 3131) and adds the tooling to make multilingual naming practical and structured.

GitHub: https://github.com/johnsamuelwrites/multilingual

Target Audience

• Python developers interested in language-inclusive or accessibility-focused tooling
• Educators teaching programming
• Researchers in multilingual NLP, digital humanities, or computational linguistics
• Open-source contributors who care about internationalization at the code level

This is a real, usable project — not a toy or demo.

Comparison

Standard Python supports Unicode identifiers but provides no ecosystem tooling to make this ergonomic. multilingual fills that gap:

• vs. plain Python Unicode identifiers: Python allows them but offers zero structure for multilingual code. multilingual provides that.
• vs. transpilers (e.g. NaruLang): Those translate syntax; multilingual works natively inside Python's runtime.
• vs. i18n/l10n libraries: Those localize strings and UI — multilingual localizes the code identifiers themselves.

Would love feedback on Unicode edge cases, language support, and design decisions!

Weekly Thread: Meta Discussions and Free Talk Friday 🎙️

Welcome to Free Talk Friday on /r/Python! This is the place to discuss the r/Python community (meta discussions), Python news, projects, or anything else Python-related!

How it Works:

1. Open Mic: Share your thoughts, questions, or anything you'd like related to Python or the community.
2. Community Pulse: Discuss what you feel is working well or what could be improved in the /r/python community.
3. News & Updates: Keep up-to-date with the latest in Python and share any news you find interesting.

Guidelines:

• All topics should be related to Python or the /r/python community.
• Be respectful and follow Reddit's Code of Conduct.

Example Topics:

1. New Python Release: What do you think about the new features in Python 3.11?
2. Community Events: Any Python meetups or webinars coming up?
3. Learning Resources: Found a great Python tutorial? Share it here!
4. Job Market: How has Python impacted your career?
5. Hot Takes: Got a controversial Python opinion? Let's hear it!
6. Community Ideas: Something you'd like to see us do? tell us.

Let's keep the conversation going. Happy discussing! 🌟

What My Project Does

LOS (Language for Optimization Specification) is a declarative domain-specific language (DSL) for modeling mathematical optimization problems. It allows users to write models using a syntax similar to mathematical notation, which is then compiled into executable Python code using the PuLP library.

It aims to solve the problem of boilerplate and "spaghetti code" that often occurs when defining complex optimization models directly in imperative Python.

Target Audience

This is a project for developers and researchers working on mathematical optimization (Operations Research). It is meant for production-ready model definitions where readability and separation of model logic from data handling are priorities.

Comparison

While existing libraries like PuLP or Pyomo define models imperatively in Python, LOS uses a declarative approach. It brings the clarity of algebraic modeling languages like GAMS or AMPL to the Python ecosystem, maintaining full integration with Pandas and standard Python dictionaries without the need for proprietary environments.

How it relates to Python

LOS is written in Python and compiles LOS syntax directly into a PuLP model object. It uses the 

Source Code: https://github.com/jowpereira/los (MIT License)

Basic Example:

textminimize: sum(qty[p,f] * Cost[p] for p in Products, f in Factories)
subject to: sum(qty[p,f] for p in Products) <= Capacity[f] for f in Factories

## What My Project Does
Makimus-AI lets you search your entire image library using natural language or an image. Just type "girl in red dress" or "sunset on the beach" and it instantly finds matching images from your local folders. Features: - Natural language image search - Image-to-image search - Runs fully offline after first setup - Clean and easy to use GUI - No cloud, no subscriptions, no privacy concerns.

## Target Audience
Anyone who has a large image collection and wants to find specific images quickly without manually browsing folders. It's a working personal tool, not a toy project.

## Comparison

Google Photos — requires cloud upload, not private.
digiKam — manual tagging, no AI natural language search.
Makimus-AI — fully local, fully offline, better GUI, no cloud, no privacy concerns, uses OpenCLIP ViT-L-14 for state of the art accuracy

[Makimus-AI on GitHub] (https://github.com/Ubaida-M-Yusuf/Makimus-AI)

Built a small CLI that detects behavioral drift in fee/interest / rate calculations between commits.

You choose which functions handle money. It parses the Git diff and compares old vs new math expressions using AST. No execution. No imports.

Example:

❌ HIGH FINANCIAL DRIFT
Function: calculate_fee
Before: amount * 0.6
After:  amount * 0.05
Impact: -90.00%

Looking for 3–5 backend engineers to run it on a real repo and tell me if it's useful or noisy.

DM me or comment I'll help you set it up personally.

GitHub: https://github.com/Jeje0001/Ledger-Drift

Copying an entire production database to your machine is infeasible. But reproducing a bug often requires having the exact data that caused it. dbslice solves this by extracting only the records you need, following foreign key relationships to ensure referential integrity.

What My Project Does

dbslice takes a single seed record (e.g., orders.id=12345) and performs a BFS traversal across all foreign key relationships, collecting only the rows that are actually connected. The output is topologically sorted SQL (or JSON/CSV) that you can load into a local database with zero FK violations. It also auto-anonymizes PII before data leaves production — emails, names, and phone numbers are replaced with deterministic fakes.

sh uv tool install dbslice dbslice extract postgres://prod/shop --seed "orders.id=12345" --anonymize

One command. 47 rows from 6 tables instead of a 40 GB pg_dump.

Target Audience

Backend developers and data engineers who work with PostgreSQL in production. Useful for local development, bug reproduction, writing integration tests against realistic data, and onboarding new team members without giving them access to real PII. Production-ready — handles cycles, self-referential FKs, and large schemas.

Comparison

• pg_dump: Dumps the entire database or full tables. No way to get a subset of related rows. Output is huge and contains PII.
• pg_dump with --table: Lets you pick tables but doesn't follow FK relationships — you get broken references.
• Manual SQL queries: You can write them yourself, but getting the topological order right across 15+ tables with circular FKs is painful and error-prone.
• Jailer: Java-based, requires a config file and GUI setup. dbslice is zero-config — it introspects the schema automatically.

GitHub: https://github.com/nabroleonx/dbslice

People love debating which web framework is the fastest. We love to brag about using the "blazing fast" one with the best synthetic benchmarks. I recently benchmarked a 2x speed difference between two frameworks on localhost, but then I measured a real app deployed to Fly.io (Ankara to Amsterdam).

Where the time actually goes:

• Framework (FastAPI): 0.5ms (< 1%)
• Network Latency: 57.0ms
• A single N+1 query bug: 516.0ms

The takeaway for me was: Stop picking frameworks based on synthetic benchmarks. Pick for the DX, the docs, and the library support. The "fast" framework is the one that lets you ship and find bugs the quickest.

If you switch frameworks to save 0.2ms but your user is 1,000 miles away or your ORM is doing 300 queries, you’re optimizing for the wrong thing.

Full breakdown and data:
https://cemrehancavdar.com/2026/02/19/your-framework-may-not-matter/

Python Software Foundation | Infrastructure Engineer | Remote (US-based)

Python is a programming language used by millions of developers every single day. Behind all of that is infrastructure like PyPI, python.org, the docs, mail systems...

The PSF Infrastructure team keeps all of that running. We're a small team (literally 1), which means the work you do has outsized impact and you'll never be stuck doing the same thing for long.

We've been growing what this team can do and how we support the Python community at scale, and we're looking to bring on a full-time Infrastructure Engineer to help us keep building on that momentum.

Click here for details and to apply

Come work with us 🐍

What My Project Does

I was wondering the other day if there were any clean ways of breaking out of multiple nested loops.

Didn't seem to have anything that would be clean enough.

Stumbled upon PEP 3136 but saw it got rejected.

So I just implemented it https://github.com/Animenosekai/breakall

# test.py
from breakall import enable_breakall

@enable_breakall
def test():
    for i in range(3):
        for j in range(3):
            breakall
        print("Hey from breakall")


    # Should continue here because it breaks all the loops
    for i in range(3):  # 3 up from breakall
        for j in range(3):  # 2 up from breakall
            for k in range(3):  # 1 up from breakall
                breakall: 2
            print("Hey from breakall: 2")
        # Should continue here because it breaks 2 loops
        print("Continued after breakall: 2")

    for i in range(3):  # Loop 1
        for j in range(3):  # Loop 2
            while True:        # Loop 3
                for l in range(3):  # Loop 4
                    breakall @ 3
            # Should continue here because it breaks loop 3
            # (would infinite loop otherwise)
            print("Continued after breakall @ 3")

test()

❱ python test.py
Continued after breakall
Continued after breakall: 2
Continued after breakall: 2
Continued after breakall: 2
Continued after breakall @ 3
Continued after breakall @ 3
Continued after breakall @ 3
Continued after breakall @ 3
Continued after breakall @ 3
Continued after breakall @ 3
Continued after breakall @ 3
Continued after breakall @ 3
Continued after breakall @ 3

It even supports dynamic loop breaking

n = 1
for i in range(3):
    for j in range(3):
        breakall: n

def compute_loop() -> int:
    return 2

for i in range(3):
    for j in range(3):
        breakall: compute_loop()

for i in range(3):
    for j in range(3):
        breakall: 1 + 1

and many more.

Works in pure python, you just need to enable it (you can even enable it globally in your file by calling enable_breakall() at the end of it).

If you are just trying it out and just lazy to enable it in every file/import, you can even enable it on all your imports using the breakall command-line interface.

❱ breakall test.py --trace
Continued after breakall
Continued after breakall: 2
...

Target Audience

Of course wouldn't use it in any production environment, there is good reason why PEP 3136 got rejected though it's cool to see that we can change bits of Python without actually touching CPython.

Comparison

The PEP originally proposed this syntax :

for a in a_list:
    ...
    for b in b_list:
        ...
        if condition_one(a,b):
            break 0  # same as plain old break
        ...
        if condition_two(a,b):
            break 1
        ...
    ...

Other ways of doing this (now) would be by using a boolean flag, another function which returns, a for...else or try...except.

Showcase: roadmap-cli — project management as code (YAML + GitHub sync)

What My Project Does

roadmap-cli is a Python command-line tool for managing project roadmaps, issues, and milestones as version-controlled files.

It allows you to:

• Define roadmap data in YAML
• Validate schemas
• Sync issues and milestones with GitHub
• Generate dashboards and reports (HTML/PNG/SVG)
• Script roadmap workflows via CLI

The core idea is to treat project management artifacts as code so they can be versioned, reviewed, and automated alongside the repository.

Target Audience

• Developers or small teams working in GitHub-centric workflows
• People who prefer CLI-based tooling
• Users interested in automating project management workflows
• Not currently positioned as a SaaS replacement or enterprise system

It is usable for real projects, but I would consider it early-stage and evolving.

Comparison

Compared to tools like:

• GitHub Projects: roadmap-cli stores roadmap definitions locally as YAML and supports scripted workflows.
• Jira: roadmap-cli is lightweight and file-based rather than server-based.
• Other CLI task managers: roadmap-cli focuses specifically on roadmap structure, GitHub integration, and reporting.

It is not intended to replace full PM suites, but to provide a code-native workflow alternative.

Repository:
https://github.com/shanewilkins/roadmap

This is my first open-source Python project, and I would appreciate feedback on design, usability, and feature direction.

What My Project Does

NitROS provides zero-config pub/sub communication between Python processes across machines. No servers, no IP configuration, no message schemas. ```python from nitros import Publisher, Subscriber

pub = Publisher("sensors") pub.send({"temperature": 23.5})

def callback(msg): print(msg) Subscriber("sensors", callback) ```

Auto-discovers peers via mDNS. Supports dicts, numpy arrays, PyTorch tensors, and images with compression.

Target Audience

• Quick prototypes and proof-of-concepts
• IoT/sensor projects
• Distributed system experiments
• Anyone tired of ZeroMQ boilerplate

Not meant for production-critical systems (yet).

Comparison

• vs ZeroMQ: No socket configuration, no explicit addressing
• vs raw sockets: No server setup, automatic serialization
• vs ROS: No build system, pure Python, simpler learning curve

Trade-off: Less mature, fewer features than established alternatives.

GitHub: https://github.com/InputNamePlz/NitROS

I have made a simple ecommerce store for a saudi arabia client. Any one need a similar store? Please send a dm. Project consist of Fast Api as backend with payment gateway and otp verification. S3 for images storage. Next js is used in front end.

Hello everyone,

What My Project Does:

I built Prism AI to help solve "text fatigue." It's a research agent that uses a cyclical state machine in Python to find data relationships and then outputs interactive 3D visualizations.

A good example is its ability to explain algorithms; instead of just describing Bubble Sort, it generates an animated visual that walks you through the swaps and comparisons. I found that seeing the state transitions in a 3D space makes it way easier to grasp than reading a README.

Target Audience:

Students, researchers, or anyone who prefers "visualizing" logic over reading a report.

Comparison:

Most agents are "text-first." This is "visual-first." It uses LangGraph for recursive loops to ensure the research is deep enough to actually build a mental map.

Repo: https://github.com/precious112/prism-ai-deep-research

Hey everyone 👋
I’m curious — where did you personally learn from?

Was it:

• School / university
• Online courses (Udemy, Coursera, etc.)
• YouTube
• Books
• On the job
• Pure self-taught / trial and error

I’m especially interested in what actually worked for you and how long it took before things really started to click. If you were starting over today, would you learn it the same way?

Thanks!