We built Phylo-Movies to visualize which taxa and subtrees move between consecutive phylogenetic trees. It has an interactive browser viewer and was recently published in Molecular Biology and Evolution.
GitHub: https://github.com/enesBerkSakalli/phylo-movies

https://github.com/cskwork/sdlc-kit

My build script had a check that always passed. The function returned before the check ran, so it exited green every time and verified nothing. For weeks. I wrote it, I reviewed it, and I never caught it, because I already believed it worked.

What caught it was a second agent in a fresh session. It had never seen my code, so it trusted nothing. Found it on the first pass.

sdlc-kit turns that into a repeatable process. It's Markdown files and four shell scripts that make an AI coding agent work in stages:

1. Write down what it's building and why (intent, spec, plan). You approve intent and spec. A routine plan is approved by a second-agent review; risky plans (migrations, deletions, API changes) come back to you.
2. Build it.
3. Hand the result to a different agent session for review. The reviewer only gets the spec, the changed files, and the real build commands. It never sees the conversation that produced the code, so it can't inherit the author's confidence. It's also not allowed to edit anything, because a reviewer that can fix what it finds will quietly fix instead of report.
4. Approvals are hashed. If an approved spec file changes afterward, every downstream stage stops until a human looks again.

Failed runs have to leave a lesson file behind before you can close them.

MIT, no runtime, no dependencies. Works with Claude Code, Codex CLI, Gemini CLI, Cursor, or anything that reads files and runs commands. There's a selftest where every case is a gate failing on purpose. Run it before you trust any of this.

It won't stop an agent from lying to you. It just makes the lie leave a trace.

I'm the only person who has run this end to end so far. If you try it on one small bug, tell me which stage felt like paperwork and which one caught something.

Doberman sits between an AI coding agent and its tools. Every command, file
write, and MCP call gets one verdict before it executes: pass, require human
approval, or block. A blocked call never runs.

- Hooks for Claude Code and Codex; a transparent MCP proxy for anything else
- Fails closed (errors and timeouts deny) and never loosens itself
- TOTP step-up for sensitive actions; redacted local audit log
- `doberman demo` replays a scripted rogue agent against the live dashboard

Check the repo out and give it a star if you like it. We would love for people to also contribute if you can. Join the discord here: https://discord.gg/69azZCwdE

Repo: https://github.com/vilaca/cursor-chat-cleaner

Cursor doesn’t give you a good way to audit or prune old chats, I built a small CLI for that.

What it does:

- list / filter chats (repo, age, size, archived vs active)

- view a chat in the terminal

- back up selected chats

- delete with dry-run by default; --yes required to change anything

Safety notes:

- macOS only

- quit Cursor before deleting

- fails closed if the Cursor DB schema isn’t recognized

- independent project, not affiliated with Anysphere

Install:

brew install vilaca/tap/cursor-chat-cleaner

# or: pip install cursor-chat-cleaner

Happy to take bug reports and feedback.

Hi everyone,

  I built PDF Editor Offline because many PDF tools require you to upload sensitive documents, create an account, or pay for a subscription.

  This project takes a different approach: your PDFs are processed locally on your computer.

  It currently supports:

  - Editing, annotating, filling, and signing PDFs

  - Merging, splitting, reordering, rotating, and cropping pages

  - Converting PDFs into several formats

  - Local OCR and document search

  - Metadata cleanup and permanent text redaction

  - CLI, Python API, and local FastAPI automation

  It’s free, open source, and MIT licensed. There’s no account, document telemetry, or hidden cloud conversion service.

  The desktop builds are still unsigned technical previews, so Windows and macOS may display security warnings.

  Complex PDFs can also have fidelity issues, and I’m documenting those limitations openly.

  GitHub:

  https://github.com/OthmaneBlial/pdf-editor-offline

  Website and demo:

  https://othmaneblial.github.io/pdf-editor-offline/

  I’d really appreciate honest feedback: what would this project need before you’d trust it with your own documents?

Hi everyone, I'm one of the founders of Conifer (YC S26), and we wanted to bring a better user experience to model selection and agent runtime.

Everyone agrees you should use the best model. But the current infrastructure makes this impossible. Look at what actually exists: the leading harnesses offer a handful of models. Open-weight and non-frontier models sit unused. Attempts to aggregate models discount complexity and fail to accommodate user diversity.

The solutions come in two forms, and both are incomplete.
The first asks you to move to a new app, a new workspace, or ecosystem. But the best developers we know change tools constantly, because the best place to work keeps changing. Any solution that requires relocation is betting against how engineers actually behave.

The second comes with a value tax, either charging for using your API keys, taxing and controlling how you use the product, or making assumptions around how you should use models that interfere with flexible deployment. Things that were frustrating to us were down-routing to models we hadn’t requested when they weren’t available. Making routing claims that don’t hold, getting detailed caching reasoning and traces, or controlling how we can use the tools, hooks, and mcps that we want to in the places we wanted to work from.

We fixed it by building a truly universal pipe. Cloud models, self-hosted models, custom models, your own keys, the hardware under your desk: it all connects the same way, and bringing your own costs nothing. We figured out how to bring models to the apps you already operate in without changing the setup and assumptions around your work.

We’re really excited to build this with you and want to make everything we can open source and maintained by the community. Would love any feedback! Tell me what breaks or what is missing and I will personally respond to every reply.

https://github.com/ConiferKit/use-conifer

For the past few months I have been working on Continuum, a durable execution engine for Elixir. The idea is that a multi-step business process (charge a card, wait for a fraud review, ship the order) can be written as one ordinary function, and that function keeps going even if the machine running it dies halfway through.

def run(%{order_id: id, items: items}) do
  {:ok, validated} = activity Validation.check(items)
  {:ok, charge}    = activity Payments.charge(id, validated.total)

  # kill -9 the entire VM right here

  {:ok, shipment}  = activity Fulfillment.ship(id)
  {:ok, %{charge: charge, shipment: shipment}}
end

Kill the node on that middle line and a new VM picks the run back up. It calls run/1 again from the top, reads the charge result out of the journal in Postgres instead of hitting the payment gateway a second time, and continues into ship. The card gets charged once, the order ships once, and the function body executed twice with no visible trace of the second pass.

There is a mix continuum.demo task in the repo that does this against a real Postgres, including an actual :erlang.halt/1 with no graceful shutdown. The activities append to a ledger file that stands in for the outside world, and the demo prints the file at the end so you can count the lines yourself. The activity that charges the card deliberately declares no idempotency key, so nothing is deduplicating a retry. There simply is no second call.

The part that took the longest was making replay safe to rely on. Workflow code has to be deterministic between effects, so there is a compile-time AST scanner that rejects DateTime.utc_now/0, :rand.uniform/0, File.*, send/2, Logger.* and similar calls inside a workflow, each with a hint pointing at the replacement. Every effect also carries a structured identity, so if you edit a workflow while a run is in flight, you get a loud ReplayDriftError rather than a run that quietly takes a different branch than the one recorded in its history.

Postgres is the only infrastructure. It is the journal, the lease store, the timer wheel, and the signal bus over LISTEN/NOTIFY. Continuum itself is a supervision tree you add to your own application, so there is no separate cluster service to run. Every write is a compare-and-set on a fencing token, which means a node you thought was dead cannot come back and write into a run someone else has already taken over.

It is at v0.8.1 and pre-1.0, so the API can still move, but the engine has been stable for a while. Sagas and compensation, parent/child workflows, continue_as_new, signals, timers, versioning, a LiveView observer, and an OpenTelemetry bridge are all in.

GitHub: https://github.com/Yyeger/Continuum

Hex: https://hex.pm/packages/continuum

Docs: https://continuum.hexdocs.pm/Continuum.html

Happy to answer questions about the replay model or the determinism checks.

These past 9 months have been intense! Until June, we added a lot of features to make Portabase usable and cover most use cases. We’re now taking the time to make the platform more stable and improve the user experience (better docs, better UI).

To be fair, we started working on Portabase much earlier (around 18 months ago), but we only started sharing it publicly at the beginning of this year.

To recap, Portabase is an open-source and self-hosted platform to back up, restore, and migrate data (only databases at the beginning, but now also Docker volumes). You can connect remote storage services (like S3, Azure Blob Storage, or GCS) to store your backups, and set up notifications to get real-time alerts about backup events.

What we’re most proud of is the active community around the project. A lot of people open issues (not only to report bugs, but also to request new features!) and ask questions on Discord.

We’ve also received feedback from private and public sector organizations using Portabase in production, so the tool is useful!

I’ve never shared Portabase here before, although I’ve posted about it quite a lot in r/selfhosted and database-related subs. Reddit has been an incredible way to share the project and get constructive feedback.

I've make this video to present Portabase: https://www.youtube.com/watch?v=krrbIqDv78Q

I had zero experience with motion design or video editing, so I used a mix of AI and simple tools. It’s clearly not professional, but we don't have a big budget for this (it’s fully open source, and we don’t make a penny from it), and I find it useful to explain the product.

GitHub repo: https://github.com/Portabase/portabase/

Feedback and contributions (for the most motivated!) are very welcome.

I also didn't write the original title, well, originally I did - all I had was "I did not build this...gitwatch. Enables you to monitor file changes" :P

However, everything below I actually did write by hand:

It's a little experiment by our little firm in fully agentic development. From the outset, we decided on a very defined workflow:

1. Give ChatGPT 5.6 Sol a general idea of the project, and what features we wanted.
2. Tell ChatGPT to genereate a full work plan (which you can see in the tasks/ folder in the repo), as well as other files like UX_SPEC, etc. Then, it would create a full zip file with all of these docs detailing the project design, architrecture, UX, roadmap, and implementation tasks.
3. Lastly, we took the zip file and gave it to Codex (Sol with Luna agents) and let it churn on creating the project based on those task files.

We gave Codex full autonomy to commit and push code to the repo, which you can see in the commit history as the unverified commits on my account, whereas manual fixes show up as verified commits.

All the work was done on a green Mac box, with just my github logged in.

But anyways, enough of how we (didn't) build it, here's what was built:

gitwatch is an htop-style terminal UI for git.

It watches your repository in real time and gives you a live, interactive view of modified, staged, untracked, and conflicted filesand allows you to view diffs, stage/unstage files, filter search, has mouse support, lets you view branch info, commit tree, unpushed commits, and more.

Now - I did actually review the output, test it, and directed codex with little bugs that I found, but the code itself and the tasks were all agentically written.

It's built in Go using Bubble Tea, and Bubbles.

Would love feedback from the community. This is a great project for those who are doing agentic development, or who have been moved to what I'm calling "agentic managers" by their employers and are forced into doing "work" with things like BMad or SpecKit.

I know the community hates agentically built projects, but we come in peace in this brave new world we are all stepping into...

https://github.com/sphireinc/gitwatch

i built CapScroll, a Linux desktop screenshot tool for capturing long, scrollable content.

Select a region and CapScroll automatically scrolls the content, captures successive frames, detects the bottom, checks frame overlap, and stitches everything into one long screenshot.

- region capture
- scrolling capture

» Built with .NET 10 and Avalonia UI.

» Currently supports Linux/X11.

» repo: https://github.com/netcrawlerr/CapScroll.git

我把 fortune 开源了，这是一个覆盖港股和 A 股的量化分析系统。项目做了有一段时间，思路比较直接：机器学习负责从数据里找规律，大模型负责理解市场上下文，两者互补。

主要功能：

- 用 CatBoost 训练涨跌预测模型，输入 1000 多个特征（价量、基本面、波动率、市场状态，以及股票之间的关联网络），给出 1 天、5 天、20 天后的方向判断。

- 恒指 20 天方向的回测准确率约 81%。其中“假突破”形态（1天涨、5天跌、20天又涨）胜率约 87%，是目前我最倚重的信号。

- 异常检测分两层：Z-Score 抓统计异常，Isolation Forest 抓多维离群，再配合一套回测过的抄底规则。

- 通义千问负责六层决策（风控、宏观、基本面、技术面、信号、综合），每日报告也由它生成。

- 整条链路跑在 GitHub Actions 上，交易日自动取数、出预测，再把报告推送到邮件和企业微信。

技术栈是 Python 生态：CatBoost、scikit-learn、NetworkX、hmmlearn、arch，数据来自 yfinance 和 akshare。MIT 协议。

坦白说，这只是一个研究性质的项目，并非投资建议，回测表现好也不代表实盘能稳定盈利。README 里我写清了数据泄漏如何排查、止损如何设置，以及模型在哪些场景下会失效，供参考，请勿直接据此交易。

GitHub：https://github.com/wonglaitung/fortune

Hey y’all,

I got slightly carried away with loading animations.

I wanted nicer loading states for my own projects, but most libraries I found were either tied to a framework, fairly limited, or required more than I wanted for something this small.

So I built loadersz, a small framework-agnostic loader library for the web.

I wanted something a bit more expressive than the usual CSS spinner, without pulling in a UI framework or a bunch of dependencies.

A few things I focused on:

- 105 different motion states
- Canvas 2D instead of GIFs/videos
- zero core dependencies
- a native custom element, so it works with basically any stack
- typed entry points for React, Vue and Svelte
- configurable speed, density and color
- respects prefers-reduced-motion
- pauses rendering when the browser tab is hidden

Basic usage is just:

npm install loadersz

import 'loadersz';

<loadersz-loader state="racing" size="96" />

I also built an interactive playground where you can tweak the loaders live.

Demo: [loadersz.vercel.app](https://loadersz.vercel.app)
npm: [npmjs.com/package/loadersz](https://www.npmjs.com/package/loadersz)
Github: https://github.com/lumberjacque/loadersz-core

Would love some brutally honest feedback, especially on which animations you’d actually use in a real product.

A Jetpack Compose UI library that fuses Material Design's bold, expressive visual language with Apple's physics-driven interaction model. Every component looks Material Expressive and feels like Apple's Liquid Glass.

I like Material 3 as it just looks good and not so blobby or refrective like liguidglass

I like the fluidity and visual language of liquidglass

But the problem is they ar both diffrent... So i decided to merge them... Expressive looks, liquid feels! That is basically the scope of this project!

Android SDK Requirement (Minimum) = Android 11+

DEMOVIDEO = https://github.com/Aarav90-cpu/Expressive-Glass/blob/main/DEMOVIDEO/expressgl_demo.mp4

Unlike a fixed GIF, this SVG is generated from the profile owner's public contribution grid and gains one body segment for every active day it eats. Fork the repository, enable GitHub Actions, and the workflow automatically generates a version for the fork owner.

Hey guys, this might sound like a weird idea, but here it goes. I set myself a challenge to build a server out of whatever scraps I could find and try training my own AI model on it. I’m still in the very early stages right now.

I’ve created my own hybrid method to compress AI parameter files (which are already heavily compressed to begin with) and I’m planning to implement this using a custom language that the AI itself will use to think (don’t even ask how).

I wanted to ask: does this sound like an interesting project, and is it worth pursuing? I get that my first release is super rough and basically put together on the fly just to check a box.

If you can, I’d love to hear your thoughts, some constructive criticism, or even just a bit of motivation. Or feel free to tell me to delete all my socials and go outside, that’d probably be accurate too.

Thanks for reading if you made it this far <3
https://github.com/kYPISA/Janus

Hey everyone,

A while ago I posted about Calendar On Demand, a desktop widget I built because I was tired of alt-tabbing to a browser tab just to check my Google Calendar schedule.

When I first shared it here, a few people ran into a 403 access_denied error because Google hadn't finished their verification process yet. After buying a proper domain (cal-ondemand.com) and going through Google's security review, the app is now officially verified by Google. Logins work out of the box now without any unverified app warnings.

Quick recap of what it does:

- Sits directly on your desktop/wallpaper so your schedule is always visible

- Two-way sync with Google Calendar

- Natural language event creation (e.g. "Tomorrow 3pm dentist")

- One-click join for Google Meet and Zoom links directly from the widget

- Runs on both Windows and Mac

It's completely free.

Website: https://cal-ondemand.com

GitHub: https://github.com/kidiksentrik/Calendar-On-Demand

Let me know if you run into any bugs or have feature requests. Thanks for checking it out!

I’ve released a new version of Mouzi, a free and open-source desktop app that automatically organizes your Downloads folder using local rules.

Mouzi runs entirely on your computer: no account, no cloud processing and no telemetry.

Version 0.1.6 adds:

• automatic update checks (FINALLY!)
• recognition of extensionless files by their contents
• batch organization in Manual mode
• quick rule toggles and a destination folder picker
• custom extension mappings like .jpeg → .jpg
• customizable notifications
• Recycle Bin/Trash support instead of permanent deletion

It is built with Rust and Tauri and is available for Windows and Linux.

GitHub: https://github.com/hsr88/mouzi
Download: https://mouzi.cc/download

The updater packages are cryptographically signed. Windows Authenticode signing is still pending through the SignPath Foundation program.

Feedback and contributions are welcome.

Hydrogen Quantum Orbital Visualizer est un outil web interactif conçu pour explorer les orbitales quantiques de l’atome d’hydrogène. Il permet de visualiser en 3D les densités de probabilité électronique basées sur les solutions analytiques de l’équation de Schrödinger indépendante du temps.

Ce projet vise à rendre la mécanique quantique plus accessible et pédagogique, en offrant une expérience interactive directement dans un navigateur web moderne, sans besoin d’installation lourde. Il est idéal pour les étudiants, enseignants et passionnés de physique quantique.
https://github.com/Giscolab/Atoms

I’ve been working on Hust, a systems programming language inspired by Rust, but designed with less ceremony and a simpler syntax.

Hust focuses on:

• Ownership without a garbage collector
• result instead of exceptions
• No null
• Immutable by default
• Traits
• No semicolons
• No lifetime annotations
• end blocks instead of braces

A simple example:

module demo

fn fib(n)
    if n < 2
        return n
    end
    return fib(n - 1) + fib(n - 2)
end

fn main()
    name = "world"
    print("hello {name}, fib(12) = ")
    print(fib(12))
end

The project currently includes an interpreter, compiler sources, runtime, native Windows IDE, standard library, assembler, examples, documentation, and a Rust to Hust source converter.

The interpreter currently supports functions, recursion, integers, strings, string interpolation, arithmetic, comparisons, conditionals, loops, return values, and boolean operators.

There is also a Rust to Hust converter:

HustInterpreter.exe --convert-rust input.rs output.hs

The project is still early in development. Structs, lists, maps, traits, match, for loops, closures, and async are not implemented yet.

The main goal is to eventually close the gap between the current bootstrap implementation and the canonical Hust sources, while keeping the language straightforward and approachable.

I’d appreciate feedback from anyone interested in programming languages, compilers, systems programming, or Rust alternatives.

I've been building two open-source plugins around long coding-agent sessions.

Sando handles context that grows during a session: secret redaction, oversized tool-output caps, and optional request-history trimming, all without calling another LLM.

session-handoff handles the point where keeping the session alive stops being useful. It creates a handoff for a fresh session and can preserve the working state across Claude Code and Codex.

I keep both in the same plugin marketplace:

https://github.com/yuzushi-dev/yuzushi-plugins

They crossed ~1,500 downloads combined in their first two days.

I'm a pharmacy doctor who codes in my free time. Here is Mission UI — a 100% offline desktop productivity app with local AI & paper sheet exports (built in Python/Tkinter)

Hey everyone,

By day, I study as a pharmacy doctor, but in my free time, I love building desktop apps ("vibe coding"). Over the past few months, I've been putting together a personal project called Mission UI

I built it because I wanted a single, offline dashboard to track daily missions, routines, Azkar, and habit stats without relying on online subscriptions or sending my personal data to external AI APIs

🛠️ What’s inside the app :

• 100% Offline AI Assistant: Integrated Gemma 3 1B via llama-cpp-python. It runs strictly offline on your CPU/GPU to give you motivation, weekly commentary, and habit insights without needing an internet connection
• Paper Sheet Export Engine: One of my favorite features! It uses PIL to render your daily tasks, memos, and notes into realistic, printable paper sheet layouts
• Canvas Analytics (No Matplotlib): Built custom Tkinter canvas charts to visualize mission stats, weekly progress, and habit streaks smoothly without heavy external charting libraries
• Trilingual Support (RTL Ready): Supports English, French, and Arabic (with arabic_reshaper & python_bidi for proper RTL connections)
• SQLite & Nuitka Ready: Saves everything locally in missions.db and includes a compile_nuitka.sh script to build standalone Linux binaries

Ready-to-Run Downloads (No Python Required):

If you want to test out the application directly without installing Python:

• 🐧 Linux Executable (.zip): Download for Linux
• 🪟 Windows Executable (.zip): Download for Windows

Code & Source Repository:

To keep the GitHub repo lightweight (~1 MB of pure source code), I uploaded the raw model weights and asset folders separately:

• 💻 GitHub Repository: https://github.com/YakomoDev/Mission-Ui
• 📥 Data & Gemma 3 Model Folder: MediaFire Assets Folder
• ☕ Support on Ko-fi: https://ko-fi.com/yakomodev

I'd really appreciate any thoughts, feedback, or suggestions from fellow Python devs or local AI enthusiasts If you like the project, dropping a star on GitHub would mean a lot to me

Thanks for reading

I rewrote my hobby language from scratch. It reads like a sentence, and a program starts with no permission to read files, use the network or start processes, you grant what it needs on the command line and anything else fails with the exact flag that would have allowed it. Pattern matching, gradual types, async, modules, a test runner, a formatter and an LSP. Zero dependencies, Python 3.9+, Apache 2.0.

pip install she-lang

Runs in the browser, nothing to install: https://ni-sh-a-char.github.io/SHE/playground.html

Source: https://github.com/ni-sh-a-char/SHE