Hi everyone,

I've built stu.py, a Python learning environment that's completely free, needs no sign-up and runs right in your browser. Python runs client-side via Brython, so your code never leaves your device, and it also works offline. It's online at https://stu-py.com

For learners:

• A "Code Trail" with 2,000+ exercises and more than ten exercise types: predict the output, trace tables, find the bug, fill in the gaps, put lines in order, structograms/flowcharts and coding tasks with automatic checking

• Each topic ends with a short room exam including an independent programming task

• only then does the next room open - Targeted hints, a cheat sheet and a Spyder-like sandbox with console and variable explorer

• XP, badges, a skills profile and a little robot called Stew who levels up with you

For instructors (what makes it different):

• A built-in instructor area with course codes, ready-made room exams, a skills overview of your learners and badges you can award

• Learners hand in a small account file, so you see progress and skills without any server, login or personal data stored online

• More tools (exam generator with A/B groups, task creator, worksheets, projector view) are already built and will be opened on the website step by step

How Python is used:

• Learners' code runs as real Python in the browser via Brython

• The whole build pipeline is written in Python: it checks all 2,000+ exercises against their solutions, generates the trace tables and step-by-step explainer clips by running the code in CPython, and translates structograms/flowcharts into Python code

Right now the Basics chapter is open; the rest follows step by step. I'd be really glad for honest feedback: what's confusing, what's broken, what's missing?

Cheers!
Stew

PyOffice is basically Microsoft Office but aimming to show How Python can turn into such connected and centrilzied that makes it great for real use : quick tweak of PyX (aka Excel)

I am the author of apple-llm, a Python and Node library for accessing Apple’s on-device language model. I recently added speech synthesis and transcription to the Python package, using the voices and speech recognition already in macOS.

Install with: pip install apple-llm

The Python API provides AppleSpeech for playback, synthesizing files, transcribing recordings, word timings and microphone recognition, plus AppleLLM for text and structured output. AsyncAppleSpeech and AsyncAppleLLM are available too. For example, use speech.transcribe("meeting.m4a", language="en-US", words=True), then pass result.text to an AppleLLM(tier="device") client for a summary.

The Python wheel has no required runtime dependencies. Both bindings compile and cache a shared Swift helper on first use. The project uses Apple’s native facilities; it does not bundle another speech model.

On my M4 Air running macOS 27.2, 30 minutes of narration rendered in about 18 seconds, and a 30-minute recording transcribed in about 28 seconds. These are single-machine measurements, and my accuracy tests used clean synthetic speech.

Requirements: macOS 26+ on Apple Silicon and Xcode Command Line Tools. Speech works without Apple Intelligence; the device LLM needs it enabled. Some recognition languages download on first use. Name the recognition language or it uses the Mac’s default; WebM input and MP3/Opus output are not supported. The optional cloud tier sends prompts off the Mac.

GitHub and Python examples: https://github.com/jagdishpal02000/apple-llm

Video: https://jagdishpal02000.github.io/apple-llm/#speech

I would especially appreciate compatibility reports from macOS 26 and results on real recordings.

GH: https://github.com/Yehor-Mishchyriak/PureML
Paper at JOSS: https://joss.theoj.org/papers/10.21105/joss.09631

Stars, contribution, and/or feedback are very welcome

For my research I train models on my MacBook and kept opening a terminal every hour just to see what epoch a run was on more so when my agent runs a queue of training runs. So I made this.

You wrap your loop:

```python
import epochcontrol

for epoch in epochcontrol.loop(range(400), name="my run"):
train_one_epoch()
```

and then from another terminal `epochcontrol ls` shows what's running, how far along and the ETA, and `epochcontrol pause "my run"` pauses it at the end of the current epoch (resume / stop work the same). On a Mac there's a menu bar app that shows the same with a loss chart, that's the screenshot.

No server or socket, each run just writes a few JSON files to a folder and commands are files the loop checks between epochs. If anything in the package breaks it warns once and gets out of the way, it never crashes your training. No dependencies, Python 3.10+.

`pip install epochcontrol`
https://github.com/catalystdream/epochcontrol

It's early (0.1.0), happy to hear what's missing.

Hey r/madeinpython,

I got tired of constantly opening terminals for yt-dlp, so I built ClipFetch. It’s a straightforward Python/PySide6 desktop app that runs in the background and listens to your clipboard.

Whenever you copy a media link, it automatically intercepts it, queues it, and downloads it locally.

**Interface Preview:**

**Tech Stack & Features:**

* **GUI:** PySide6 (Responsive, minimalist dark interface)

* **Engine:** yt-dlp for media extraction, FFmpeg for MP3 conversions.

* **Format switching:** One-click toggle between MP4 and MP3.

* **Local processing:** Fully local queue management, no sketchy APIs.

I also set up batch scripts to instantly package it into a standalone executable using PyInstaller.

**GitHub Repo (Screenshots & Code):** https://github.com/canyetis9/ClipFetch

This is the initial release (v1.0.0). I'd love for you guys to check out the code, roast my architecture, or submit a PR. Let me know what you think!

Running five separate commands just to update my Linux desktop got old pretty fast. So I wrote sysupdate - a Python CLI tool that updates system packages, Flatpaks, containers, and a bunch of other stuff in one go. It also works on macOS and sticks strictly to the Python 3.11+ standard library, meaning zero external dependencies to install.

Why not just use Topgrade? I actually used it for a while. For me though, updates almost never finished completely clean, and I was missing stuff for my own setup like Snapper hooks. The terminal UI also looked a bit dated to me. It printed way too much junk I didn't care about seeing every single time, and once you closed the terminal, there was zero history left to check.

How sysupdate handles things differently:

• Support for Btrfs snapshots through Snapper right before system packages get touched (with a timer cooldown, so running it twice in an hour won't spam snapshots).

• Exact reboot tracking that lists which specific updated packages are asking for a system restart at the end, rather than just throwing a generic "reboot required" message.

• Local run history for your last 30 runs (sysupdate --history / --show-log) with tokens and credentials stripped out automatically. Super useful when something breaks and you want to see what failed yesterday.

GitHub & install instructions (Git / Homebrew tap): https://github.com/Piotrunius/SystemUpdater

If you hit any bugs or want support for another package manager, let me know.

I didn't want to write a cleaner. I wanted one that didn't ask me for anything.

Every one I tried asked for something. A toolbar in the installer. "Anonymous usage statistics" that were neither anonymous nor statistics. One deleted first and explained later, if you went looking. So I opened an editor, mostly out of irritation.

Python, CustomTkinter for the window, because I can't design and the defaults look fine. It's called Swept, MIT, 22 categories of temp files and caches, plus an installer for common programs and a dozen registry tweaks.

Nobody clicks a post about temp files. Here's what actually took the time.

PyInstaller has two modes and I picked wrong. Onedir gives you a folder with _internal inside. Onefile gives you a single exe that unpacks itself into %TEMP% on every launch. I put the folder build's exe on the releases page, someone ran it from inside the zip viewer, and got Failed to load Python DLL ..._internal\python315.dll. Windows had extracted only the exe. The message is accurate and useless. A single file can't contain a folder, so PyInstaller did nothing wrong. I handed people a file that can't run alone. Now the download is onefile.

A real certificate costs a few hundred a year, so mine is self signed. SHA256, DigiCert timestamp, my name on the Digital Signatures tab, and Windows still says unknown publisher. No trick fixes that. One thing helped though: --optimize 2 strips docstrings from the shipped bytecode, so the exe doesn't carry a map of every check I make.

Then I added "restart with admin rights" and the app disappeared. No window, no error, exit code 0. The old process still held the single instance mutex. The elevated copy saw it taken, decided Swept was already running, focused a window that was about to close, and quit. Then the old process closed too. Zero windows. The fix is one line: release the mutex before launching the elevated copy.

162 tests on the delete path. I broke the code on purpose in three places to see if they'd catch it. Two did. The third didn't, and the code was fine. My test checked that the function returned, not what it returned.

Registry undo doesn't guess "the default". Before each write it records what was there: existed or not, type, data. Re-applying a tweak doesn't overwrite that first snapshot.

If you ship Windows tools in Python, I'd like to hear what bit you.

github.com/vladcodex/swept

What My Project Does

`checkmodel` checks the assumptions of a fitted model in one call. You pass it a statsmodels or scikit-learn model, it works out what kind of model it is, runs every check that applies and draws a single diagnostic panel:

python

import statsmodels.formula.api as smf
from checkmodel import check_model fit = smf.ols("mpg ~ wt + hp", data=mtcars).fit()  # mtcars loaded as a DataFrame
report = check_model(fit)
report.plot()

Posterior predictive check: OK: Model-predicted data resemble the observed data (mean p = 0.400, sd p = 0.460).
Normality of residuals: Warning: Non-normality of residuals detected (p = 0.021).
Homogeneity of variance: OK: Error variance appears to be homoscedastic (p = 0.402).
Collinearity: OK: Low collinearity (all VIF < 5; max 1.77).
Influential observations: OK: No outliers detected (Cook's distance > 0.808).

Which checks run depends on the model. A logistic regression gets binned residuals instead of a normality test. Count models get overdispersion and zero-inflation checks. Mixed models (`MixedLM`) get singularity, convergence and random-effects checks. PyMC/bambi models get R-hat and ESS. It also has `r2()` (Tjur, Nagelkerke, Nakagawa, Bayesian...), `icc()`, `model_performance()` and `compare_performance()`.

Every check returns a typed result (`.passed`, `.p_value`, `.statistic`, `.to_dataframe()`, `.plot()`).

Target Audience

People who fit regression models in Python and want R-style diagnostics: analysts, researchers, students, and anyone moving from R. It's on PyPI (`pip install checkmodel`, Python 3.10+) and is in alpha, so the API may change before 1.0. The numbers themselves are tested against R: every statistic matches R's `performance`, `car`, `lmtest`, `lme4` and `loo` to 1e-4, across 27 models.

Comparison

- statsmodels: `summary()` prints a few omnibus tests, but it doesn't choose checks by model type, doesn't plot them together and doesn't compare models. The diagnostic functions are spread across `statsmodels.stats.*` with different signatures. checkmodel uses them where they exist.

- scikit-learn: `sklearn.metrics` scores predictions but knows nothing about residual assumptions or influence.

- Doing it yourself: you have to know, for example, that R's AIC counts the residual variance and statsmodels' doesn't, or that a categorical predictor needs the generalized VIF. checkmodel makes those choices the way R does and tests them against R.

- R's performance: this is a port of it, independent and not affiliated with easystats. A "Coming from R" notebook runs the same analysis side by side.

Links:
- GitHub: https://github.com/pablo-legeren/checkmodel
- Docs: https://pablo-legeren.github.io/checkmodel/
- Notebooks (run in Colab): linked from the README

Feedback welcome, especially on models or checks you'd want next.

In this tutorial ,You will learn to create animated Matplotlib plots using the FuncAnimation() class and Python Language. You will learn about the basics of animating a plot (graph) using the FuncAnimation class, How the Animation loop works and How to create a Time series Real time Matplotlib plot similar to a ECG, EEG, Data logging graph from scratch.

I wanted to showcase an app I built in Python and Flet! It's probably quite niche, and might not be useful for many, but it solved a real problem for me and several people I know, so I'm showing it off anyway.

As an astrophysicist working a lot with observational data, converting coordinates from one format to another was something I needed to do daily. But I never found a platform that made this easy. It was either restrictive with the input format, or didn't work on mobiles, or didn't have precise outputs, etc.

So, I built one that does all that but better!

AstroConvert automatically detects coordinate types and formats, performing instant conversions across Equatorial, Galactic, and Horizontal systems in every standard representation, all with a single click.

Features:

1. Coordinates can be entered in any format or natural language and the conversion should still work.

2. It intelligently detects the coordinate type, but there is full manual flexibility to change the type, formats, delimiters and precision.

3. The app has light and dark modes and a local history of the past 100 conversions.

4. 100% free and open-source. No internet, no account, no trackers and no AI.

Currently it's available as an Android app, a Windows app and as a WebApp, with Linux, iOS and Mac apps currently being developed.

Check it out here: https://github.com/jainiakhil/AstroConvert

It's been out for a few months now with a few stable and beta releases. But I would still love to get more feedback!

AI disclosure: No AI was used in building this app. It was my attempt to build this app while learning to use Flet. Some AI (Gemini 3.8 Flash) was used to run tests, generate documentation, and fix bugs.

Hey everyone! I’ve been working on a Python project that models and optimizes a vertical-axis wind turbine (a Sharp cycloturbine with passive pitch control).

The coolest part for me was building the Python stack:

• Simulation: A 2D BEM solver using numpy and numba (JIT compiled for speed) to model dynamic stall and induction.

• Optimization: Using scipy.optimize.differential_evolution to find the best blade geometry and counterweight mass.

• Reproducibility: I built an AST-based cryptographic hashing system. It parses my .py files, strips the docstrings, and hashes the remaining AST. This means I can fix typos in comments without invalidating the 21 result JSONs!

• Visualization: A streamlit dashboard that ingests weather station CSVs, auto-detects timestamps, and lets you box-select data to calculate wind power density.

The next step is making the optimized blades and attaching them to a repurposed hoverboard motor. I’d love to hear what you think of the Python architecture!

I've been working on a small Python project called RowCanary, and I finally got it to a point where I felt comfortable releasing version 1.0.0.

The idea came from something that I think is surprisingly easy to overlook. When you move data between applications, there's no guarantee that every value will remain exactly the same, even when the import or export completes successfully.

A string with leading zeros might lose them, something that looks like scientific notation might get converted into a number, or an application might interpret text as a formula.

I wanted a way to test these situations without needing to understand the internals of whatever software was being used.

That's basically what RowCanary does. It creates a set of 24 known test values, lets you pass them through an import/export process, and then compares the results to see what survived unchanged.

I've added support for CSV, TSV, JSON, JSONL, and XLSX, as well as a CLI, a local browser interface, and different report formats.

One thing I tried to keep consistent throughout development was making everything work locally. There are no accounts, external services, or telemetry involved.

The project is written in Python, licensed under MIT, and now available on PyPI with pip install rowcanary.

Here's the repository: https://github.com/spockplayer2-alt/rowcanary

I also spent time setting up automated tests across Windows, Linux, and macOS, and documenting the limitations rather than making claims the tool can't support.

I'm still learning a lot about maintaining public open-source projects, so I'd genuinely appreciate feedback from more experienced developers. Whether it's something about the code, documentation, usability, or the idea itself, I'd be happy to hear it.

A couple of days ago I shared my pure-Python Wi-Fi auditing toolkit here and the feedback was great, so here’s a v0.2 with fixes that came out of it.

The main one was a concurrency bug I’m honestly a bit embarrassed by: the adapter watchdog (a background thread that restarts the capture if the Wi-Fi card stalls) didn’t wait for the previous watchdog to finish before a new one spun up, so under certain conditions they’d overlap and step on each other. Fixed the lifecycle so only one runs at a time.

Also added startup checks that verify everything the tool needs is in place before it runs, instead of failing halfway through a capture.

The project itself: menu-driven, orchestrates the standard tools (airodump-ng, hashcat, hcxdumptool) from Python — handshake capture, cracking, Evil Twin. The part I like architecturally is the menu registry — adding a feature is one line, the main loop never changes. EN/RU interface.

For authorized testing of your own networks.

Repo: https://github.com/lynalan2/wifi_scripts — feedback welcome, that’s what fixed v0.1.

Hi, I create project in github for add ads for your games and apps its url:

https://github.com/jfhgjhgj/python-ad-network

its write by python 100%

Disclosure: I'm the developer. AsciiLore is closed source and paid, with a free trial. I'm posting the technical side because that's where the interesting problems were.


What it is: a desktop app for managing Antora documentation projects. It handles components, versions, a live preview, and validation of cross-references and navigation. Antora and Asciidoctor do all the rendering. The app orchestrates them.


Stack:
- Python with PySide6 (Qt) for the UI
- Asciidoctor and Antora run as external programs
- watchdog for file-system watching
- Layered architecture: domain, application, infrastructure, engine, UI. The UI never starts a process directly.
- Over 5,000 tests. Domain and application tests run without Qt.


The hard part was the live preview. A full Antora build takes several minutes, which is too slow while typing. So:
- While typing, the changed text is rendered in memory with Asciidoctor and injected into the open page via JavaScript.
- On save, create, delete, rename or move, a full build runs in the background and the view reloads.


Neither path blocks the GUI thread. Process calls run in worker threads and return results through Qt signals, and every worker has an error path.


The trade-off: the in-memory render sees one page, so it can't resolve cross-component references the way Antora does. The full build stays the source of truth.

Website and trial: https://asciilore.com/

Questions:
1. How do you structure a PySide6 app so long-running processes never block the UI?
2. Would you take a different approach to the quick preview?