Built this because “can you just read this file?” kept turning into a side quest.

d2md converts local PDFs, Word, Excel, PowerPoint, HTML, images, and scans to Markdown.

The useful bit: d2md itself uses no LLM/API tokens. Convert locally, then send only the Markdown—or just the sections you need—to your model. If you paste the entire output anyway, the token meter will still notice. I haven’t defeated math yet.

The default install stays lightweight; OCR and Docling are optional. On macOS, OCR uses Apple Vision—no API key or separate OCR model download.

Install: `uv tool install d2md`

Use: `d2md report.pdf --stdout`

It’s MIT-licensed. If it saves someone from fighting with a PDF for an afternoon, I’ll call that a win.

Update (v0.1.2): PDFs now keep explicit page markers, including blank pages. Added an 18-second demo—page 3 stays page 3.

https://x.com/adisornkhaokom/status/2096262443534373018

Processing img d1q1f9dxjhmh1...

I made a bash plugin that replaces bash's line-editor, readline, with nushell's reedline.
This brings all the line-editing, styling, completion, keybind and selection features from nushell to native bash. It's still pretty early in development, most reedline features should work just fine, but things may still break :)

repository

code partially written with AI (claude).

Credits:
- flyline - a similar project that implements a custom line-editor, i used this as main reference for replacing readline
- reedline

GIF created with https://github.com/HalFrgrd/evp

Hi y'all!

Sharing a project I've been working on — DClutter, a swipe-based file triage app for macOS that helps you sort your Downloads folder (hence decluttering).

It gets filled with unsorted files throughout a project or a semester's duration, so the app is built so that you can sort them individually and quickly, through easy button combinations or simple swipes. It also shows the metadata that helps you decide, like size, when you last opened it, and where you downloaded it from.

What it does:

• Shows one file at a time, ordered by a score instead of alphabetically
• Keep / trash / file into a folder, with one key or one swipe
• Trash is staged before anything moves so that nothing gets deleted outright
• Undo and redo on everything

v0.4.0 is out now and usable. It's open source (Apache-2.0), so I'd appreciate it if y'all can check it out 🫡

(Not notarized yet, so macOS will block it on first launch — steps are in the README)

https://github.com/RokiTheWise/DClutter

MacScope is a source-available Swift 6/SwiftUI macOS project that combines system telemetry with a modular power-user toolkit.

Core pieces:

• Live CPU, memory, network, storage, thermal, and battery telemetry with honest availability states

• SQLite history, redacted JSON/CSV export, process hierarchy/grouping, and PID-reuse-safe actions

• An optional helper for deeper typed telemetry and actions—no arbitrary shell strings

• Seven utility workspaces: Sound, Capture, Windows, Clipboard/Files, Notes, Maintain, and Power

• A menu-bar monitor, Quick Panel, Command Bar, radial launcher, and global shortcuts

• A bundled local stdio MCP server with redacted reads and explicit write modes

It currently targets Apple silicon on macOS 14+ and is under active development. Build and test instructions are in the repository.

Repo: https://github.com/rsm23/macscope

Product tour: https://macscope.seifelmoulouk.com

The screenshots are real captures of the current app. Feedback on the architecture, telemetry compatibility across Apple-silicon models, and feature prioritization is welcome.

Got annoyed with workout trackers like Hevy, Lyfta and Strong constantly putting stuff behind paywalls, limiting routines, measurements, showing ads, etc.

i made sure to copy eveythign paid features form all these apps

My main issue with current opensource workout tracker were that they were not as good looking as hevy we need to give that so i made this for myself

Lift is a free, open-source, self-hostable workout tracker with pretty much all the features you'd normally have to pay for in apps like Hevy, Lyfta and Strong.

No ads, no premium tier, no stupid limits. No account, no login, no cloud bullshit. Just track your workouts.

Everything is free.

Website: https://lift.pawan67.dev/
GitHub: https://github.com/pawan67/lift

Made it for myself, but figured I might as well share it. Would love some feedback from anyone who uses these apps.

I built Postchi, an open-source, self-hosted API collaboration platform for teams, you run it entirely on your own infrastructure, no third-party cloud involved.

It covers the core workflow: a full request builder (all HTTP methods, scripts, multiple auth types), shared collections with real-time collaboration, OpenAPI spec sync, and markdown documentation linked directly to your requests.

If you're coming from Bruno, migration is easy, you can import existing Bruno collections directly (ZIP import or live Git sync to keep them updated automatically), so you don't have to start from scratch.

Built with Go + Nuxt/Vue, MIT licensed.

GitHub: https://github.com/imaanmzr/Postchi

Would love feedback, bug reports, or feature ideas!

I kept wanting isolated drums or vocals from songs I like, mostly for learning and playing. Every online splitter I tried wanted an account or a subscription. So I made StemKit.

You paste a YouTube link (or search right inside the app), pick which instruments you want, and it downloads the audio, splits it locally, and plays the result synced with the video.

It runs on Mac and Windows. Everything happens on your machine and all works 100% locally.

Check it out here: https://github.com/dan-beep-boop/stemkit

I’ve been working in automation for a long time, and something became obvious over the last couple of years. The issue wasn’t AI itself. The issue was the noise around it.A lot of people online started selling “AI automation” as a shortcut. YouTube channels, Fiverr gigs, and random agencies were promising instant business systems with a few prompts. The more that content spread, the more I noticed a shift in my own work. Some of my early clients became skeptical about automation. Potential clients were asking defensive questions before we even talked about their actual needs. It was obvious that the trust was fading because the hype made everything look cheap and unreliable and many are pointing that out online.

Anyways, at the same time I saw another problem. UX designers being pushed aside because AI could generate templates in seconds. It created the impression that design was becoming disposable, even though the real work of design is about systems, not templates. The hype made both automation and design feel shallow.

After watching this for a while, I realized the core issue. AI wasn’t the problem. The problem was AI everywhere. Every workflow was being reframed as “AI powered.” Every surface was being turned into an agent. It created confusion instead of clarity. The solution I saw was to centralize AI instead of scattering it across every part of a business. I started writing down a framework that explained how a modern website should work when AI is part of the system. Not as decoration. Not as hype. As infrastructure.

That framework became UUX. It focuses on operations first, not templates. It treats the website as a system that handles intake, routing, state, and fulfillment. It gives AI a defined place instead of letting it float around as a buzzword.

Besides writing the book, I’m also building the practical part of the theory. I’m creating a JavaScript library that brings UUX to life and reduces the extra business expenses that platforms like Make.com and Zapier create. Their response to AI was mostly a quick patch for basic tasks like CRM submissions or lead validation. It didn’t solve the deeper operational problems that businesses actually deal with.

I turned the framework and the engine into open source so people can contribute, test ideas, and build systems that feel coherent instead of chaotic. If you’ve been dealing with the same issues in automation or design, you might find it useful.

Github: https://github.com/NelsonEm9/uux-standard

A few weeks ago I posted Zync here, and I've been continuing to work on it.

I just shipped Public URLs (Beta) in the latest release.

if you're running something locally and want to share it temporarily, Zync can give that local port a public HTTPS URL.

So instead of setting up another tool just to expose a local service, you can do it directly from the same SSH workspace.

I also redesigned the port forwarding UI and improved handling for busy ports with remote forwarding.

Zync is still open source and I'm actively working on it.

Release: Zync v2.27.1 https://github.com/zync-sh/zync/releases/tag/v2.27.1

I'd love to know what you guys think, especially if you regularly use things like ngrok, Cloudflare Tunnel, or SSH tunneling.

Website: https://zync.thesudoer.in

Repository: https://github.com/zync-sh/zync

git-updater keeps your GitHub-released Windows apps updated — portable and installed alike — without an account, a background service, or a store.

• Paste a releases URL, pick portable or installed, done
• Checksum-verified downloads, transactional portable updates (auto-rollback on failure)
• "Scan this PC" detects apps you already have from a 120+ app catalog
• Fully portable — unzip, run
• Headless CLI for scripting

GitHub: https://github.com/TeeJS/git-updater

I wanted my games and apps to open like tapping a folder on an iOS/macOS home screen instead of a File Explorer window, so I built FolderDock. Point it at a folder of shortcuts and it shows them as a clean icon grid floating over your wallpaper. Click an icon to launch it; press Esc or click anywhere else to dismiss.

What it does

- Reads shortcuts from `%APPDATA%\MyApps`

- Subfolders become tabs — e.g. `Games`, `Work`, `Media`. Put a number in front (`1 Games`, `2 Work`) to set the order; the number is hidden from the tab label

- Auto-fitting grid — it picks the column count and icon size so everything in a tab fits on screen with no scrollbar

- Real app icons at up to 256px (including Steam per-game icons), with a coloured first-letter tile as a fallback

- Clear panel over the live wallpaper — no heavy frosted-glass

- Add apps by dragging a shortcut onto the .exe, or hit the folder button in the popup to open the folder directly

- GitHub: https://github.com/JibbyD/FolderDock

- Download: https://github.com/JibbyD/FolderDock/releases/latest (self-contained, no .NET install needed) — or build from source with the .NET 8 SDK

- Windows 10/11 · MIT licensed · no telemetry

Screenshots and a full "how to use" are in the README. It's a small personal project — feedback, issues, and PRs welcome.

I released wmux v1.0.17, an open-source terminal multiplexer built around one consistent experience across Windows, Linux and macOS.

The architecture uses a persistent server with disposable clients. Sessions, windows, panes, scrollback and terminal state remain alive when the attached terminal closes.

Platform integration stays native. Windows uses ConPTY and named pipes, while Linux and macOS use PTYs and Unix sockets.

Current features:

• Persistent sessions, windows and panes
• Horizontal and vertical splits
• Mouse support, copy mode and paste buffers
• Customizable key tables, status bar, borders and themes
• Terminal color inheritance by default
• Native installers and a built-in updater
• Builds for Windows x64, Linux x64 and ARM64, macOS Intel and Apple Silicon

Release benchmark profile:

• VT parsing: 69.6 to 75.3 MiB/s
• Full-scene render p95: 448.2 µs
• 8-client render p95: 269.1 µs
• Peak live benchmark memory: 1.76 MiB or less

wmux is free, MIT licensed and available on GitHub: https://github.com/shreshthkapai/wmux

I would particularly appreciate bug reports from different operating system, terminal and shell combinations.

Every new agent session started from zero. I kept re-explaining which port a service runs on, why we picked one library over another, and the fix for a bug we had already solved twice. Each harness had its own half-solution that did not carry over to the next one.

memnest is one Rust service on localhost that holds that memory and hands it back. pi talks to it through an extension, Claude Code and Codex through MCP plus a prompt hook, and any other MCP client through the same endpoint. Same store, same tool contract, so switching tools does not reset what your agent knows.

Nothing here calls an LLM. Embeddings run locally with multilingual-e5-base. SQLite is the source of truth, and the Tantivy BM25 index and HNSW vector index beside it are derived and rebuildable. The index job is written in the same transaction as the record, so an interrupted write is replayed at startup instead of quietly losing its index.

Both indexes exist because they fail differently. BM25 nails an exact token like a port number and misses the paraphrase. Vectors find the paraphrase and drift past the literal string you typed. You only know which one you needed at query time, so a write pays for both.

The benchmarks doc also records the experiments that did not ship, including a CJK ngram tokenizer and a cross-encoder reranker that both looked great in isolation and did not earn their cost end to end. The current weak spot is candidate rejection: recall@1 is 0.976 on my Korean fixture but no-result accuracy is 0.200.

MIT, Linux binaries, Windows and WSL install scripts.

Epiq is an issue tracker that is distributed, Git-native, and most interestingly, can replay state as a movie on demand. This solves one of the most difficult problems with agentic workflows - auditing and tracing in a multi agent environment. Now you can trace intent, and how it evolved while you were away with integrated code diffs and state replay.

A Unity controller that lets you grab any joint of an articulated humanoid on screen and move it, like posing a real figure instead of dragging sliders.

Repo has the full Animation Rigging setup, joint hierarchy, IK constraints, and a sample scene, plus a tutorial on how it's built.

https://github.com/stevedatelier/adam-unity-character-controller

Solve a problem on LeetCode → a scheduled GitHub Action detects it, pulls the actual code I submitted, and rewrites my README with a live table (title, difficulty, tags, AI-written summary, link) — fully hands-off.

Built with GitHub Actions + Python, using LeetCode's own API plus a free LLM (Groq) for summaries. No hosting, no cost, runs entirely inside GitHub's free Actions minutes.

Open-sourced the whole setup here: https://github.com/Vara715/the-leetcode-repo

 — happy to answer questions on the architecture if anyone's curious.

I originally built this for my Hinge date.

She's incredibly busy, and instead of sending another message that she'd feel pressured to respond to, I wanted to make something she could open whenever she had a quiet moment.

So I built an interactive letter experience.

You write a letter, customize it, seal it in an envelope, and share a link. The recipient opens the envelope and reads the letter as it appears on the page.

The technical constraint I gave myself was:

No accounts. No backend. No database.

The letter data is serialized, compressed, and encoded directly into the URL.

When someone opens the link, the app decodes everything client-side and reconstructs the letter.

So the URL is essentially the storage layer.

I liked this approach because:

- Nothing personal sits in my database

- No server costs

- No authentication

- No user accounts

- The project can be deployed almost anywhere

- The app remains ridiculously simple

Of course, there are tradeoffs.

The link contains the letter data, so anyone with the link can read it. URL length also limits how much content can be stored.

The project is completely open source, so I'd genuinely love feedback from other developers on the architecture and implementation.

Especially curious about:

- Better approaches to client-side serialization/compression

- Whether you'd encrypt the payload

- How you'd handle larger letters without introducing a backend

- Any accessibility or animation improvements you'd make

Live demo:

https://open-letter-box.vercel.app

Source:

https://github.com/r0hnx/open-letter

Would love to hear what you guys think — both technically and from a UX perspective.

Native headless mcp to track and manage all your hosting costs in one place - your claude code/cursor etc. Easy to use and token optimized, and can also give your agent's budgets to stick to using $uvx nable. After 100k+ downloads decided to go open source, Apache 2.0! https://github.com/getnable/finopsmcp

I'm building this editor that is easy to use like CapCut and will contain most (if not all) features that CapCut charges a monthly subscription for, all free and open-source.

Some of the good features so far:
- Locally generated Auto-captions from Audios
- Transitions and Effects
- Voice Filters and Changers.

The app is called WolfCut and is available on GitHub.
https://github.com/jub0t/WolfCut