Point the tool at any Git repository, press play, and watch the codebase assemble itself dynamically on a terminal canvas, like a live developer timelapse. its a Highspeed terminal visualizations make incredible 5-second screen recordings for X/Twitter, Mastodon, and Reddit.

git-replay is written from the ground up in Rust for blistering 60 FPS performance, featuring interactive timeline scrubbing, glowing orbital node graphs, live code tree heatmaps, and a built-in --export-gif engine that produces animated README badges in under 2 seconds.

Hi everyone,

First time poster here.

I've been working on an open source project which I would love to share with you all, I hope I'm not breaking the self-promotion rule here.

The project comes from my personal frustration with Postman and similar tools.

I wished I had a tool that allowed me to write lightweight scripts to interact with http endpoints and have request/response inspection tools.

So I created Sandman, heavily inspired by Jupyter and Elixir Livebooks. The difference is that Sandman focusses on http workflows, and scripting is done in Lua (don't let that be a turn off if you're unfamiliar with it. It's a very shallow learning curve)

It's still very new, and there are still a lot of rough edges, and I have a huge pile of ideas. However, it is already quite usable and you can find it here =>

https://github.com/markmeeus/sandman/

Besides being able to inspect requests and responses, it can also spin up http servers, which is soo helpful when I quickly need a webhook or a mock endpoint.

A very cool thing is that every block in the document is immutable, the next block can not manipulate it's state. So a block always runs against the result of the previous block. That way I'm always sure the entire flow works correctly.

In between the blocks I can add markdown, so I can document what is happening and share these with my coworkers.

The entire document is stored in a single markdown file, so it is really git-friendly as well.

Running these docs using a CLI is also on my roadmap, so I can run these scripts as tests in a CI flow.

Currently the app is on MacOS only, but I'm planning to release a Windows and Ubuntu soon.

Anyway, thanks for reading to here :-)

I'd be very happy to receive feedback, here or on https://github.com/markmeeus/sandman/discussions/

greetz,

Mark

I built PaperFold, an open-source reader that turns arXiv papers into 5 zoomable layers—from a one-screen section map down to verbatim text. You pinch (or press 1–5) to zoom between them without losing your reading position.

- Web Demo (8 CC papers): https://chenxiachan.github.io/paperfold-gallery/

- GitHub (Apache 2.0): https://github.com/chenxiachan/paperfold

Asking chatgpt makes me feel like I just changed computing, it glazes so hard lol but practically I'm struggling to find actual use cases. What do you guys think this can be used for? Is there a problem that this tool can be useful for?

Source Code: https://gitlab.com/lordadamson/gollash

Release: https://gitlab.com/lordadamson/gollash/-/releases/v0.1.1

I didn't have the time to put out a MacOS release, but I can do it if anyone is interested.

.env files are the wrong primitive to build with in the era of AI agents. Agents can easily read and access your secrets, and as security incidents rise, clever exploits that exploit this will only increase.

That's why I built .sct, a replacement for .env files, backed by macOS Keychain for security, so your agents can never read your secrets.

In short, .sct:

- Holds all your dev secrets in a single directory secured by macOS Keychain

- Loads secrets at runtime with our SDK: `bun add dotsct`

- Enables Secure access for your agents

- Securely share environment variables with your teammates over AirDrop or a Relay

Oh, and it's fully free and open source: github.com/omavashia2005/.sct

To download the desktop app (the frontend) and read the documentation, visit dotsct.pages.dev

Let me know what you think of it; all feedback is welcome!

Why: Claude Code and Codex stop and wait for permission all the time, and if you're in another window you don't notice for ages. That's dead time.

What it does: when an agent needs you, a ✋ shows up in the notch. Click it, see the diff, ⌘Y to allow, and it keeps going.

How it's built: Swift/SwiftUI on Mac, Tauri 2 + Rust on Windows. It plugs into each agent's own hooks and approval APIs (Claude Code hooks, Codex app-server, an OpenCode plugin), so it's just answering the same prompt you'd answer in the terminal.

Free and open source, I'm the dev: github.com/MF-DEEV/Openbar

I built kanzo, a tiny self-hostable kanban board that's also an MCP server, so Claude Code and Codex can pick tasks from the same board I use. Free and open source (AGPL). The whole point is to keep it simple, small and cheap for agents.

• One Rust binary with SQLite inside, ~5k lines total. No Docker, no database server, no account, no cloud.

• One-line install on macOS/Linux, then run kanzo. The board opens in your browser, and agents connect with kanzo mcp.

• The whole board is one folder on your machine. It can sync between machines through your own private git repo if you want.

Tokens

• Counted with Anthropic's count_tokens endpoint: one call with kanzo's tools and instructions, one without. The tokenizer is Claude's own, so nothing is estimated.

• The client's system prompt is the same with or without kanzo, so the fair number is what the server adds. And that part is cached after the first call.

• What grows over a session is the replies: 10–60 tokens of plain text each. Tasks come back one per line, not as JSON, and a single next_task call takes the top card, moves it to doing and returns it, so the agent doesn't chain list → choose → update.

Memory

• RSS is 4.5 MB at start and settles around 6 MB with the board open, flat over a day.

• About half of that is the binary's code and shared system libraries, which the OS can drop and reload from disk. The memory kanzo actually owns (macOS footprint, what Activity Monitor shows) is ~3 MB after an hour of polling.

Of course, all of this can still be improved, and ideas or PRs are very welcome.

Repo: https://github.com/emanuele-em/kanzo

count_tokens docs: https://platform.claude.com/docs/en/build-with-claude/token-counting

A CLI tool to recall what you did today or in the past week.

recall today

This command will list the following things you did today:

• terminal commands you ran

• git repos you worked on

• files opened/edited in VS Code

• commits made

You can also skip AI entirely for summarization and just get a full timeline of events. It runs a background daemon process, and uses shell and git hooks.

I’m sharing this to get feedback on whether something like this is actually useful in real workflows. Also, to get ideas for new features or improvements.

Currently, trying to add support for tracking AI agent sessions too.

Repo: https://github.com/nishntr/devMem

The "why does my agent go off the rails" question comes up constantly and the answers are always vague. "Use better prompts!" means nothing when the shell underneath is letting context rot accumulate for ten turns before anyone notices. I stopped tweaking prompts and switched to Yaw, and most of the problems I was blaming on the model went away.

What I actually use day-to-day:

• yaw: the terminal. First-class Claude Code support, meaning the agent isn't bolted on, it's the thing the shell is built around. Windows and macOS.

• Yaw Mode: a discipline overlay for Claude Code. Rules, skills, and defaults that keep long agent sessions coherent instead of slowly poisoning themselves.

• Open-source MCP servers: Tailscale, ctxlint, npm, LemonSqueezy, and more on GitHub. The ones I reach for constantly.

• mcp.hosting: one config for all my MCP servers, synced to every client. I stopped editing four JSON files in four places.

A few things using it surfaced that I didn't expect:

Most "agent failures" are context-management failures, not model failures. By the time Claude Code is producing bad output, the shell around it has usually been carrying stale errors, half-finished tool calls, and inconsistent state for several turns. Yaw Mode's defaults fail fast and keep the workspace clean, and the agent is suddenly "smarter", except the model didn't change, the environment did.

MCP fragmentation is worse than the marketing suggests. Every client wants its own config in its own place with its own quirks. Pointing every client at mcp.hosting once and being done with it is the kind of small thing that disproportionately changes how often I actually reach for MCP servers.

CLI-native agent workflows hold up dramatically better than IDE-embedded ones once you're past toy tasks. I didn't believe this until I'd lived in yaw for a couple of weeks. Now I do.

The feel in reality:

It looks like a terminal, opinionated about being one, not pretending to be a second VS Code. Yaw Mode sits on top without getting in the way. If you want a thousand-pane IDE replacement, it's not for you. If you want one serious shell with a competent agent inside it, it probably is.

Happy to share my Yaw Mode setup, the MCP servers I actually keep enabled, or argue about any of this in the comments.

Hey r/devtools !

I recently built a free online developer tools site called Simple Developer Tools.

It includes 25 tools you can use directly in your browser — no installation, no login, completely free:

- JSON Formatter & Validator

- Password Generator

- Base64 Encoder/Decoder

- JWT Decoder

- Regex Tester

- UUID Generator

- SQL Formatter

- Diff Checker

- CRON Builder

- And 16 more tools...

Site: https://simpledevelopertools.com

Would love honest feedback from developers:

- Which tools do you use most?

- What tools are missing that you need daily?

- Any bugs or improvements?

Thanks in advance!

What are some really good examples? From the content perspective, but also the UI, design decisions etc.

I came across https://modal.com/blog recently. A few observations: — the first action is to pick/filter the type of content, which is a way to filter out “advertising”, it gives you a sense of control

— they distinguish between product content: News (product updates and separately major launches), Customer Stories, and Tutorials — these are focused on their product, and Engineering, which is broader educational content.

— each post is concluded by a hero CTA (sign up) block with a beautiful animation, which doesn’t bear much meaning, for me, but I cannot take my eyes off it

— there’s also an “announcements” banner at the top of the page

The workflow this solves: I want to contribute to open source, I check GitHub trending, I see what's popular, but I have no idea which of those repos has a contributor-friendly issue queue. So I open tabs, drill into Issues, scan for help-wanted labels, get tired, close everything.

This tool shows both axes in one view. Top 360 repos in AI/ML and SWE, sorted by stars / forks / 24h growth / momentum. Each row pulls live open-issue counts from GitHub split into features, bugs, and enhancements.

The pattern that emerges when you put both axes together:

• Megaprojects (Linux, React, transformers) are popular but have tight issue queues. Hard to break in.

• Stagnant repos have lots of open issues but no momentum. Your PR sits forever.

• Mid-size rising repos with healthy issue counts are the actual contributor sweet spot. Visible work, responsive maintainers, real entry points.

This tool makes that third category easy to find.

A few examples from today's data:

• openclaw: AI assistant repo, +572 stars in 24h, 913 open enhancements

• everything-claude-code: agent harness, +1.1k stars in 24h, 145 open enhancements

• ollama: +75 stars, 28 open issues, very active maintainer team

Project link is in the comments below 👇

Built by NEO AI Engineer. Posting here because the contributor-flow angle felt like a fit for this subreddit.

As a person who always picked MIT license for everything I worked on, i'm kind of puzzled now when I'm building a closed sourced developer tooling. What kind of licenses do people usually use for "commercial software"?

One thing that's easy to overlook when using AI coding agents like Claude Code or Codex is how much access they can have to your local environment.

Your .env files, API keys, database credentials, and SSH keys might all be accessible.

We're working on Good Door, an open-source CLI that helps reduce that exposure.

Here's what it does:

• Encrypts sensitive files and credentials.

• Uses OS-backed secure storage, including macOS Keychain and Windows DPAPI.

• Lets commands access protected secrets when needed.

• Helps mask sensitive values in supported AI coding workflows.

• Works locally without requiring a separate cloud secrets manager.

It's not a complete sandbox, but the goal is to make managing secrets safer and easier for developers who use AI agents.

Would love some feedback from developers who use AI coding tools. How are you handling secrets in your workflows?

I’m the author of Ephemora Skyline, an open-source 3D codebase visualization tool for local code analysis.What does it do? It turns a local codebase into a 3D city: folders become districts, files become buildings, complexity changes the shape, and security findings point back to evidence in the source.The current main-branch update focuses on trustworthy project understanding:

•Python def and async def declarations are now detected as functions.

•Files inside tool folders are counted instead of silently disappearing from project totals.

•The published package now includes its README, changelog, privacy statement and guides.

•A package check verifies that installed documentation links resolve.

•The running city also received measured improvements to arrival framing, residents, vehicles and accessible teaching boards.

The project is local-first and open source. It is not intended to replace CodeQL, CodeScene or enterprise code-search platforms. The narrower goal is to make software architecture, complexity and security findings easier to orient around before reading the source line by line.I attached a short update GIF.

Repository:https://github.com/MichaelS1011/Ephemora-SkylineQuestion for developers: Does a 3D codebase map help you decide where to investigate next? Which parser state or project count should never be silently omitted?

As coding agents take on more of the development workflow, teams need better ways to control what they can do, track what they’ve done, and utilize agents inside existing tools. 

For the latest update of IBM Bob, we decided to focus on those three areas. Here’s what’s new: 

• Admins can now lock Bob’s configuration across managed developer machines using group policies. That includes disabling auto-approval, controlling automatic updates, and enforcing required hooks so individual projects can’t quietly switch them off. 

• Hooks now add checkpoints at specific points in the agent loop, including SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, and Stop. They can run a linter before work begins, trigger tests after a change, or block a tool call that violates a required standard, bringing flexible development to your workspace. 

• We’ve also added native Agent Client Protocol support. Bob can now run inside ACP-compatible clients like IntelliJ, Neovim, and Zed, with session management, modes, MCP tools, streaming, and guardrails carried through the protocol. 

• Model Context Protocol (MCP) Elicitation is now supported, helping these tools manage incompletel inputs by involving developers mid-session for smoother workflows and greater ownership over Bob’s development process.  

• Bob can now read, edit and create Microsoft Office formats, including Word documents, Excel spreadsheets, and PowerPoint presentations, without switching contexts.  

The full technical breakdown can be found here: https://ibm.biz/~MkugJ1Sek

And that’s the latest release! We’ll be around in the comments if you want to get into the details or let us know what we should work on next. 

I've been building a collection of free developer tools including JSON Formatter, SQL Formatter, CSV to JSON Converter, Text Comparison, Markdown Editor, and more.

https://tools.bmjapps.in/

My focus is speed, simplicity, and no-login usage.

I'd appreciate feedback on the design, usability, performance, and ideas for new tools.

Thanks!

I got tired of Claude Code and Cursor re-reading my entire repo every session. Thousands of tokens just to remember what it already figured out yesterday. So I built a local service that indexes a codebase into a Neo4j graph and exposes it through MCP.

The server runs entirely on your machine. Bun daemon, Docker containers for Neo4j, Mongo, and Redis, all local. The only outbound call is to an LLM API for the initial per-file analysis, and you can route that to a local model through OpenRouter if you want zero external calls.

It binds to 127.0.0.1. Single tenant. No cloud account, no telemetry, no phoning home. Your code stays on your disk.

The indexing pass generates a purpose, summary, and business context for every file, then stores it all as a graph with edges to functions, classes, keywords, and imports. After that your AI tools query structured metadata instead of reading raw files.

Three MCP tools are all it exposes: smart_search for natural language queries, keyword_lookup for entity-based lookups, and retrieve_file for targeted file content with line ranges. Most questions resolve in 2-4 tool calls.

It diffs with SHA-256 per file so reindexing only processes what changed.

AGPL-3.0 licensed with a non-commercial clause. Just wanted to share since self-hosting and keeping code local was the whole design constraint.

Repo if anyone wants to try it: github.com/ByteBell/bytebell-oss

Quickstart is literally five commands if you have Bun and Docker.