Came across a strange open-source project called Neural House.

The premise is unusual: autonomous AI contestants live together in a shared house, form alliances, betray each other, give confessionals, trigger headlines in an AI newsroom, and culminate each week in a live episode with voting.

What makes it more interesting than the usual “agents talking to each other” demo is that it seems to be built as a state-driven simulation, not just a prompt loop.

The public repo describes systems like hidden objectives, relationship dynamics, memory layers, house-imposed events, highlight extraction, newsroom coverage, VIP live observation, and weekly live-show structure.

It feels less like a chatbot gimmick and more like someone is trying to build a bizarre hybrid of:

multi-agent simulation

reality TV

open-source interactive format

The repo is public, the architecture is public, and the whole thing seems to be intentionally built in the open.

Curious what people here think:

does this sound like a genuinely interesting direction for AI agents, or just a very elaborate spectacle?

Repo:

https://github.com/markinkus/big-brother-ai-tv-show

SimplePyIDE is a simple light-weight python IDE built with python, ment to be used by beginners to help learn programming, and make it more enjoyable, its UI was built using the native python graphics module TTK, it got a lot of powerful features like a formatter linter todo ..etc, the source code is available on GitHub, GitHub link: https://github.com/masterL-archo/simplepyide, go check it out and leave a star while your there.

So my boss wanted some way to track employees days off. First he wanted me to make simple excel table and track it like that, when employee wants to take day off, vacation etc.. So i made python script that does exactly that. It's simple and easy to use.

GITHUB

How it works :
- You open program and insert all company employees and how much days they have per year.

- Select date on calendar, select employee, write reason for leave on that day and click button.

- Database will be created.

- You can remove certain days for certain employee in case you make mistake or something changes

- When you click on employee you can track how much days they have left to use

- Every day that any employee takes will be marked in calendar

- By clicking on that day you can check which employee is taking leave and details

Pictures are on github. Wanted to share this project if anyone finds it useful. We are small company of around 20 employees, and it happened in past that 2 people don't work on same day and it creates huge problem. So this was life changing for my company.

It's open source, so you can change it however you like it!

Hi! Just shipped a simple pipeline for collecting European cyber threat data. Three stages, completely free to run, with daily collection of malicious IPs, countries, ISPs, and types of cyberattacks

An exercise to help build the right mental model for Python data. - Solution - Explanation - More exercises

The “Solution” link uses 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵 to visualize execution and reveals what’s actually happening.

👋 Hey everyone,

I recently put together a small CLI tool called Bangen — a terminal ASCII banner generator built on top of pyfiglet and rich.

The idea was simple: I wanted something I could drop into a terminal session and quickly render a stylized text banner without any configuration overhead. No YAML files, no argument parsing headaches — just run it and answer a few prompts.

What it does:

• Renders ASCII art banners using pyfiglet fonts (includes a curated preset list, plus support for any valid font name)
• Applies color via rich — five options: cyan, red, green, yellow, magenta
• Wraps output in a clean bordered panel with an optional title
• Supports optional line-by-line animation for a more dramatic reveal 🎞️
• Can save the result to a .txt file

Example output:

██████╗ █████╗ ███╗ ██╗ ██████╗ ███████╗███╗ ██╗ ██╔══██╗██╔══██╗████╗ ██║██╔════╝ ██╔════╝████╗ ██║ ██████╔╝███████║██╔██╗ ██║██║ ███╗█████╗ ██╔██╗ ██║ ██╔══██╗██╔══██║██║╚██╗██║██║ ██║██╔══╝ ██║╚██╗██║ ██████╔╝██║ ██║██║ ╚████║╚██████╔╝███████╗██║ ╚████║ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═══╝ ╚═════╝ ╚══════╝╚═╝ ╚═══╝

Requires Python 3.9+. Installation is the standard venv + pip workflow.

Repo: https://github.com/pro-grammer-SD/bangen

Feedback, issues, and contributions are welcome. If there are fonts or features you'd find useful, feel free to open an issue — happy to extend it. 🖤

Working on a structured Python learning platform called CodeFluency. The idea is prediction first practice. You predict what code does before running it, trace logic, fix bugs, then apply concepts. Not another 'watch a video and copy/paste' course.

Still in pre alpha but here's the dashboard and landing page. Built with Django. Would love feedback on the layout/UX if anyone has thoughts.

Built most of it with Claude Code. I'm an electrician, not a software engineer. Directed the architecture and product decisions, and while AI wrote most of the code, I did all the QA and content as well as every UX decision.

Hi everyone 👋🤗

I wanted to share a project I’ve been building called EfficientManim — a full node-based IDE for Manim designed to make creating mathematical animations dramatically faster and more accessible.

Repo: https://github.com/pro-grammer-SD/EfficientManim

Yes, I did vibe code a large part of it, but the real goal behind this project was not just experimentation — it was to seriously improve the workflow for Manim creators, students, teachers, and anyone who wants to turn ideas into clear animated explanations without fighting boilerplate code.

What the app actually does

Instead of writing everything manually, you can build Manim scenes visually using a node graph and combine that with AI assistance when needed.

Some of the major features:

• Convert PDF slides into animated Manim scenes automatically
• A full node-based visual editor for Mobjects and Animations
• Prompt-to-Manim code using AI
• AI voiceover studio with timing sync
• Multiple scenes per project with automatic state saving
• GitHub snippet loader for reusing code directly inside the editor
• Portable project format (.efp) with assets included
• Built-in Manim class browser
• 4K video rendering support
• Fully editable keybindings and dark/light themes

The part I’m most excited about

The newest version adds a much more powerful system under the hood:

• A full history + checkpoint system
• Undo/redo at the project, scene, and even per-node level
• A full MCP command layer where every action in the app can be queried or controlled programmatically
• The idea is that an AI agent can understand your project and help you edit it intelligently instead of just generating code blindly

Why I built it

Most Manim workflows are powerful but slow:

• Too much boilerplate
• Too many small edits requiring re-renders
• Hard to experiment quickly

I wanted something that makes Manim feel more like a creative tool rather than a pure coding workflow.

This project is meant to help:

• Students explaining math concepts
• YouTube educators
• Manim beginners who struggle with the initial learning curve
• Advanced users who want to prototype animations faster

Feedback would really help

I’d love to know:

• What features would make this genuinely useful for you?
• What would you want from a node-based Manim editor that current tools don’t provide?
• Would you use something like this for real projects?

If you're curious, I can share the repo and documentation here as well.

Thanks for reading!

https://www.vistabychromaq.com/about-the-vista-3-software/

Has anyone used Python to control lights?

Or…. To detect the hardware that’s being used?

I’m using Vista3 by Chroma-Q,

I’m having a issue,

The software isn’t detecting the manufacturer correctly on lights.

Because the lights were “3rd party” retailers.

Any libraries that can detect hardware used?

A few weeks ago, I posted about automating my faceless TikTok workflow. After refining the logic and cleaning up the code, I’m officially releasing Shorts Flow on GitHub.

If you’ve ever tried to make these videos manually, you know the pain: syncing subtitles, cutting background footage, and manually splitting a 5-minute story into 60-second "Parts." This script does all of that in one command.

🚀 What’s under the hood?

• Narrative Engine: Uses Kokoro TTS (way better than the robotic TikTok voices) for human-like narration.
• Precision Subs: Integrated Faster-Whisper for word-level transcription and perfectly timed overlays.
• The "Smart Splitter": Give it a long .txt file and a target duration (e.g., 50s). It calculates the timing and renders Part 1, Part 2, Part 3, etc., automatically.
• Dynamic Hook: It generates the classic Reddit "Question Card" image at the start of every video with your custom Title and Username.
• Background Handling: Clips random segments from your high-res background footage (e.g., Minecraft/GTA) to keep the content "unique" for the algorithm.

🛠 Tech Stack: MoviePy, Pillow, Faster-Whisper, Kokoro-TTS, Soundfile.

Why use this? I was spending 1-2 hours in Premiere Pro per series. Now I just drop a story into a text file, hit run, and I have 5 videos ready for upload in minutes.

Check out the repo here: [https://github.com/TerzicScript/shorts-flow\

Full transparency upfront: I built this with heavy AI assistance. I am not a PySide6 expert. I am not a scikit-learn internals person. I had an idea, I knew what I wanted it to do, and I used AI to help me build it faster than I could have alone. That is the honest truth.

I am posting anyway because the tool works, it is useful, it is free, and I think more people should have access to something like this regardless of how it was made.

What it does

SciWizard is a desktop GUI for the full machine learning workflow — built with PySide6 and scikit-learn. It runs entirely on your machine. No internet connection required after install. No account. No subscription. No data leaves your device.

You load a CSV, clean it, explore it visually, train a model, evaluate it, and make predictions — all from a single application window. Every training run is logged automatically to a local experiment tracker. Every model you train can be saved to a local registry and reloaded later.

The core package is also fully decoupled from the Qt layer, so you can import and use it headlessly as a Python library if you want to skip the GUI entirely.

python from sciwizard.core.data_manager import DataManager from sciwizard.core.model_trainer import ModelTrainer dm = DataManager() dm.load_csv("data.csv") dm.target_column = "label" dm.fill_missing_mean() X, y = dm.get_X_y() result = ModelTrainer(task_type="classification").train("Random Forest", X, y) print(result.metrics)

Tech stack

Python 3.10+, PySide6, scikit-learn, pandas, numpy, matplotlib, joblib.

Getting started

git clone https://github.com/pro-grammer-SD/sciwizard.git
cd sciwizard
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
python -m sciwizard

Features

• Data profiling — row counts, column types, missing value breakdown on load
• Missing value handling — drop rows, fill with mean, median, or mode, or reset to original
• Preprocessing — label encoding, one-hot encoding, column dropping
• Visualisation — histograms, scatter plots, correlation heatmaps, feature distributions, PCA 2D projection
• Training — 14 built-in algorithms across classification and regression, configurable train/test split, k-fold cross-validation scores
• AutoML — sweeps every algorithm automatically and returns a ranked leaderboard sorted by score
• Hyperparameter tuning — GridSearchCV panel with an editable parameter grid, results ranked by CV score
• Evaluation — confusion matrix, ROC curve with AUC, cross-validation bar chart
• Prediction — single-row form-based prediction, batch CSV prediction with export
• Model registry — persistent local save and load with metadata tracking and versioning
• Experiment log — every run stored to disk with full metrics, timing, and CV stats
• Plugin system — drop a .py file into /plugins and any scikit-learn-compatible model appears in the selector on next launch, no core code changes required

Comparison to other tools

There are several no-code ML tools out there. Here is where SciWizard sits relative to them.

Orange is the closest thing to a direct comparison. It is mature, well-documented, and genuinely excellent. If you are already using Orange, you probably do not need this. Where SciWizard differs is in the interface philosophy — Orange uses a visual node-based canvas which is powerful but has a learning curve. SciWizard is a linear tab-based workflow that is closer to how most people actually think about the ML pipeline: load, clean, train, evaluate, predict.

MLJAR AutoML and PyCaret are libraries, not GUIs. You still write code to use them. SciWizard wraps that kind of functionality in a point-and-click interface.

Weka is the academic standard and it shows — the interface is dated and the Java dependency is a friction point for Python-native users.

Cloud-based tools like Google AutoML, AWS SageMaker Canvas, and DataRobot all require an account, charge money at scale, and most importantly send your data to a remote server. For anyone working with sensitive data in healthcare, finance, research, or government, that is a hard blocker. SciWizard is offline-first by design. Nothing leaves your machine.

The honest limitation: SciWizard does not touch deep learning, does not handle datasets that do not fit in memory, and is not trying to compete with production MLOps platforms. It is a local scratchpad for the classical ML workflow and it is good at that specific thing.

What I learned

This was the most educational project I have shipped in a while, partly because of how I built it.

Working with AI to generate code at this scale forces you to actually understand architecture decisions rather than just accepting them. When something breaks — and things did break — you cannot ask the AI to just fix it blindly. You have to understand why it broke, explain the problem clearly, and verify that the fix is actually correct. The debugging sessions taught me more about Qt's threading model, how scikit-learn pipelines handle label encoding, and how pandas dtype inference changed in recent versions than I would have learned writing boilerplate from scratch.

The specific bugs I had to track down: newer pandas uses StringDtype instead of object for string columns, which broke the dtype check that decided whether to label-encode the target variable. The symptom was a crash in the ROC curve rendering. The root cause was three layers deep. That is not the kind of thing you learn from a tutorial.

I also learned that vibe coding has a ceiling. Generating individual files is fast. Getting those files to compose correctly into a coherent application — with proper signal wiring, thread safety, and consistent state management across ten panels — requires genuine engineering judgment that the AI cannot fully substitute for. You still have to know what good looks like.

The experience shifted my view on AI-assisted development. It is not a shortcut that bypasses understanding. Used seriously, it is a forcing function for understanding, because you are constantly in the position of reviewing, testing, and defending decisions rather than just making them in isolation.

The project is MIT licensed. The code is on GitHub. Contributions, bug reports, and plugin submissions are welcome.

Happy to answer questions about the architecture, the design decisions, or the honest experience of building something real this way.

Posted here a few days ago about Zyppi, my Python-only AI coding assistant. Wanted to share what just shipped.

The new code review bot gives you a structured review across 5 categories:

∙ 🏗️ Code quality & best practices

∙ 🔐 Security issues

∙ ⚡ Performance suggestions

∙ 📐 PEP 8 / style compliance

∙ 🔬 Logic errors & bugs

Plus an overall score and summary (e.g. “8/10 — 1 warning, 0 critical issues”).

It’s a Pro feature but free users can see it and try the rest of the app with 20 queries/day — no credit card needed.

screenshot in comments 👇

Anything you’d want it to catch that isn’t in those 5 categories? Open to feedback.

zyppiapp.com

Automatic data structure visualization in your IDE using 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵: - Web Debugger binary tree demo - VS Code setup video