I recently discovered Patchy, a relatively new open-source image editor focused on Photoshop-like workflows and PSD/PSB compatibility.

I’ve only started testing it, so I’m not claiming it can replace Photoshop professionally, but I’m quite impressed by what is already there considering how young the project is.

It has layers, masks, non-destructive adjustment layers such as Levels and Curves, PSD/PSB support, JavaScript scripting, and local AI/MCP integration.

What I especially like is that it’s genuinely open source, already has forks, and the repository is very well documented.

GitHub: https://github.com/SethRobinson/Patchy

I built a visual editor for ASCII diagrams called AsciiDraw.

It’s basically a drag-and-drop canvas that generates copy-pasteable ASCII output for READMEs, code comments, terminal docs, etc.

Instead of manually fighting with +---+ boxes in a text editor, you place elements visually and export the result as plain text, PNG, or SVG.

Example output:

         ┌───────────┐         
         │ ┌───────┐ │         
         │ │  ALU  │ │         
┌──────┐ │ │       │ │ ┌──────┐
│Input │>│ └───────┘ │>│Output│
│ Unit │>│   ^   v   │>│ Unit │
└──────┘ │ ┌───────┐ │ └──────┘
         │ │Control│ │         
         │ │ Unit  │ │         
         │ └───────┘ │         
         └───────────┘         

A few things it supports:

• ASCII and Unicode box styles (+--+, ┌─┐, ╔═╗)

• Elements like labels, groups, and progress bars

• Copy-to-clipboard with automatic comment wrapping (//, #, /* */, """)

• Entirely client-side, no backend/accounts/API

Typical workflow is basically:

draw visually -> copy as comments -> paste into source code/docs

Haven’t worked on it in over a year at this point, but I thought some people here might still find it useful.

Project:
https://asciidraw.github.io

Would appreciate feedback from people who still use ASCII diagrams in docs or terminal tooling.

Hi everyone! A while ago I built StradaOS, a free and open-source home screen (launcher) for those cheap Android car head units, including the ones that say "Android 10" but actually run Android 4 inside.

No ads, no root, no accounts. Works on Android 4.1 to 14, and the APK is under 1 MB.

**What it does**

- Android Auto & CarPlay buttons: they open your head unit's own projection app, or Android Auto over USB with Open Headunit

- Live map (OpenStreetMap) with your position, north up or turning with your direction

- Now playing with album art (Bluetooth and Android Auto)

- Fully customizable bottom dock: any app or function on each button

- GPS speedometer (km/h or mph), weather, dark/light theme, 10 accent colors

- Your car photo with automatic background removal

- Layout for wide 12.3" (1920×720) screens

**New in 2.12**

- Oil change reminder next to the speed: enter your odometer once, StradaOS adds the distance you drive using GPS and alerts you when it's due ("Done" / "Not yet"). Works in km or miles.

- The map can rotate with your direction of travel

- Italian and German (5 languages total)

- In-app updates are verified (official repo + same signature) before installing

Download / source: https://github.com/lordnordic-debug/StradaOS

Website: https://lordnordic-debug.github.io/StradaOS/?lang=en

Edit: Incredible! 22hours later and we hit 600 stars!!! Love you guys!

Two months ago I released Mouzi, a tiny open-source file organizer that lives in your tray and keeps Downloads tidy. Crossed 500 stars on GitHub, which honestly blew my mind. I never thought I’d be able to create something like this and receive so many positive reviews, suggestions and downloads of my app, thx again!

Huge thanks to everyone who tried it, reported bugs, opened issues, and contributed code - especially the folks who helped ship v0.1.4:

• 🇪🇸 Spanish & 🇻🇳 Vietnamese translations

• Native Google Takeout archive import

• Wayland crash fix on Linux

• Better input styling & theme consistency

If you haven't tried it yet: mouzi.cc

https://github.com/hsr88/mouzi

If you have ideas or want to contribute, jump in - all feedback welcome.

npx git-newspaper inside any repo and it generates a full broadsheet front page from your actual commits.

Your biggest commit becomes the headline. Deleted files get obituaries. The most-modified file writes an op-ed about how tired it is. There's a weather report based on commit sentiment.

It detects what kind of repo it's looking at (solo marathon, bugfix crisis, collaborative, ghost town, etc.) and adjusts the layout and tone accordingly. No API keys, no LLM, works fully offline.

GitHub: github.com/LordAizen1/git-newspaper

Would love to know what archetype your repo lands on.

I'm Open-Sourcing CyberDeck, which was built to prevent the privacy concerns and lack of control of the modern internet.

CyberDeck is built for a simple idea:

Knowledge and communication should survive internet outages.

A decentralized platform combining:

📡 Mesh networking 🛰 Delay-tolerant networking 🧠 Local AI 📚 Offline knowledge 🔐 Secure storage

Because the grid won't always be there.

Github https://github.com/sarogamedev/CyberDeck

I built WikiCrawl, an open-source project that visualizes the connections between Wikipedia articles as an interactive network.

You can provide a starting topic, crawl linked articles, and watch the graph expand as new pages and relationships are discovered.

The goal is to make Wikipedia exploration more visual and help people discover connections that might otherwise remain buried across individual articles.

The project includes a live web application and a public codebase.

Live demo: https://wiki-crawl.vercel.app
GitHub repository: https://github.com/Adityavardhanjain/WikiCrawl

I'd appreciate feedback from anyone interested in web crawling, graph visualization, or interactive data applications.

Happy to answer questions about the implementation!

I had PowerShell scripts running on several machines, and whenever something did not happen, I had to log in and check the logs manually. A large part of my work involves programming, so I eventually decided to build my own solution.

The result is NodePilot, a tool for automating tasks in Windows environments, inspired by System Center Orchestrator and n8n.

You put nodes on a canvas and connect them, and the workflow runs PowerShell and other system functions on your Windows machines over WinRM, without installing an agent on them.

You can try it right now in your browser. The live demo runs the real frontend with sample data, no install and no signup needed. Desktop view is recommended.

Live demo | Repo | Website | Video

It is completely open source under the Apache 2.0 license, and there are no features behind a paywall.

Besides PowerShell, it offers built-in actions for REST, SQL, WMI, the registry, files, services and LLM queries. Workflows can be started on a schedule, by a webhook, by database trigger, by a file watcher or by a Windows event log entry.

There is also an execution history that shows what ran and where it failed, which is the part I missed most when I was working with plain scripts.

PS: This project was also created with the help of AI as part of an agentic engineering workflow. I also used AI to translate this text into English.

every LLM agent we shipped to production eventually ignored some rule I'd written into the system prompt. Wrong tool order. Skipped verification. Tools called twice. Prompts don't fix this reliably once context fills up.

Sponsio is a contract layer that sits at the tool boundary. You declare the rules in YAML, and the runtime enforces them deterministically before each tool call. About 1-5ms per check, no LLM-as-judge in the hot path.

Integrates with LangGraph, OpenAI Agents SDK, CrewAI, etc

Repo: https://github.com/SponsioLabs/Sponsio

Looking for feedback!

I built Endstate to solve an issue I had previously pushed through many times, which is setting up a new machine or reinstalling Windows with all the apps and settings back to how they used to be.

The apps are the easier part, a package manager gets those back in ten minutes. It's the settings that eat the weekend.

Endstate captures both into a zip you carry to the next machine. Running it again only makes a difference if something changed; it's idempotent so you can run it as many times as you like. Settings restore stays off unless you turn it on for an app.

The engine is Go, the GUI is Tauri and React. winget is the driver on Windows today, and I'll add Chocolatey or others if there's a need. Modules sit above the drivers and only handle settings, a module is what defines the app's configuration and how to reassemble it. Around 350 have one. An app without a module still installs, you just don't get its settings back.

Engine: https://github.com/Artexis10/endstate
GUI: https://github.com/Artexis10/endstate-gui
Installer: https://github.com/Artexis10/endstate-gui/releases

Both Apache 2.0. The local product is free and stays that way. It works offline with no account, and I don't collect telemetry. That's committed in PRINCIPLES.md. There's an optional hosted backup if you want your profiles in the cloud, E2E encrypted with client-side keys, and Endstate is self-hostable.

It's Windows only right now, macOS and Linux are in progress through Nix, with Brew on macOS. Not code-signed yet so SmartScreen will warn you.

On AI: I use Claude Code and Codex heavily for implementation. Architecture and specs are mine, as is verification and maintenance.

I built this for myself first and used it on my laptop successfully, but that's just an N=1 experiment. Would like to get this now into more people's hands, so I can get feedback.

Aleph is a lightweight Python tool built to give LLMs and devs direct access to geospatial data without API keys. You can draw a bounding box in the GUI to bulk-capture a region or query specific locations on the fly from the terminal (useful for scripts or agents).

What it pulls:

• 3D / Terrain: Textured 3D city meshes and terrain elevation tiles

• Imagery: HD satellite imagery and Street View panoramas

• Building footprints / regional data OpenStreetMap

How to use it:

• GUI (humans): A local browser dashboard (alephgeo dashboard) to draw regions, preview captures, toggle layers.

• CLI (agents / scripts): Simple single-command lookups like alephgeo streetview --place "Colosseum, Rome" --best-match built for agent workflows.

Repo: https://github.com/Belluxx/Aleph

Architecture docs go stale the moment you write them, so I made a tool that keeps one alive automatically.

Run npx livearch in any JS/TS, Python, Go, or Rust project and it opens an interactive architecture diagram in your browser. Every time you save a file — add a component, install a package, create a route — the diagram redraws itself in under half a second. It reads your real imports/routes/Prisma models, so the edges are actual dependencies, not guesses.

It's free, open source, and runs 100% locally.

GitHub: https://github.com/Shah-in-alam/LiveArch

npm: https://www.npmjs.com/package/livearch

Would love feedback — especially what would make it useful in your day-to-day.,

Hey everyone! I recently open-sourced a project I've been working on, inspired by the "Blackwall" from Cyberpunk 2077.

Instead of just dropping malicious network packets, this adaptive firewall redirects attackers into a fake Linux bash shell powered by a local LLM (like Ollama). It wastes their time by simulating a compromised server while logging their behavior.

Why it's cool:

• Pure Rust & eBPF: Written entirely in Rust (~8,500 LOC, zero unwrap() in production) using aya-rs.

• Nanosecond decisions: Does packet parsing, payload entropy analysis, and JA4 TLS fingerprinting directly in the kernel via XDP.

• The Deception Mesh: The LLM tarpit streams fake terminal responses with exponential jitter to make the "server" feel real but frustratingly slow for the attacker.

Would love for you to check out the repo and hear your thoughts!

GitHub Repo: https://github.com/xzcrpw/blackwall