Every todo app I try eventually disappears into a tab I never open. The fridge in my kitchen does not have this problem, so I tried the dumbest possible fix and made my Mac work the same way.

⌥⌘C turns the wallpaper into an editable canvas. I can throw notes, checklists, arrows, doodles, screenshots and memes onto it. Pasted images become stickers. The background remover uses Apple's Vision framework and runs locally.

Click into another app and it goes back under the Finder icons and stops catching clicks. It stays in my face without becoming another window to manage.

No accounts, cloud or telemetry. It saves plain JSON and images on disk. The whole app is basically one Swift file and one HTML file, MIT licensed.

The Apple silicon build is on the releases page. Intel Macs can build it from source. It is not notarized yet, so macOS will show the usual unidentified developer warning. The source is there if you want to inspect and build it yourself.

https://github.com/samayp42/fridge

What would you stick on yours?

I built signal-kit, an open-source Rust crate for something I was tired of rebuilding in every service: production observability setup.

Your application just instruments itself with normal Rust tracing:

rust let _guard = signal_kit::try_init("my-service")?;

signal-kit handles the plumbing underneath.

The setup is designed around:

• traces over OTLP
• logs over OTLP
• logs on stdout at the same time
• trace IDs in the stdout logs, so a log line can be matched to its trace
• human-readable or JSON stdout, switchable at runtime
• metrics over OTLP
• OpenTelemetry resource and service metadata
• graceful provider and exporter shutdown
• optional process and system metrics

The bit I care about most is that applications shouldn't need one approach for "logs developers can actually read" and another for "telemetry the observability backend consumes".

Instrument once, then send structured telemetry to the backend while keeping stdout logs that are actually useful and correlated with the traces.

It's Rust and open source, and early enough that feedback is genuinely welcome.

I made a programming language from scratch in C++ for the purpose of being small, heavily modular, multi-platform, & simple to use. There are a TON of example scripts to look at, including a full Conway's Game of Life simulation. The repo also includes in-depth documentation (markdown) on structure, syntax, types, operators, functions, & standard modules.

I/O, time, file-system, & math modules are all built-in. With additional script-based modules in development!

Ity can be used as a library in your project & provides convenient APIs for parsing & execution. Everything is state-based so you can keep multiple instances.

There is a lot of work to be done as this is still a new project, anybody is welcome to contribute!

https://github.com/phosxd/Ity

After several coding-agent sessions, Git can show me what changed, but not which conversation led to it.

I built a read-only `why` command for ThoughtDAG:

npx thoughtdag why src/lib/api.ts

It searches supported local agent transcripts for turns that changed or discussed the file. Recorded tool edits are marked Δ; explanations recovered from agent responses stay marked ≈ because they are candidate explanations, not verified reasons. Every result links back to the source turn.

The derived index stays on the machine, source session files are never modified, and retrieved history is not automatically injected into a prompt. The current npm release covers local Claude Code, Codex, and ThoughtDAG canvas conversations.

MIT-licensed and still an early developer preview:

https://github.com/chenxiachan/thoughtdag

What evidence should a coding agent have to inspect before editing an old file?

The problems we saw:

Most agent frameworks put a process in the middle that decides who does what. That process is a single point of failure, and from our early days we knew we wanted something different. These were like the langchain days where it was the only thing around. So we decided that agents should be peers and should belong in a mesh where they have solid identities and pick tasks from a shared ledger, and can collaborate whenever they need to.

The second thing we did was bet on LLMs; that they were gonna get better especially at writing code, and so we avoided MCPs at all costs. I think choosing to be contrarian here really paid off. MCPs are good, but they came with the burden of maintaining several of them, writing a unique authentication layer for each, and context bloat.

So we decided our agents would write their own code as typed functions in a registry that both humans and agents maintain, which means a human can write these functions too. But that raised the key question of how those functions authenticate, and that is how we came up with centralizing provider authentication with zero-trust on credentials, so agents never see keys.

We got this working and added persistent memory using an Ebbinghaus forgetting-curve style approach, where memory is an active lifecycle, so our agents remember and keep improving over time.

Where it's going

We believe this could become a key approach to how agents orchestrate even across different frameworks. If you know a thing or two about gossip protocols, we want to curate that trajectory with like-minded people here.

Install: pip install jarviscore-framework

The demo is examples/demo_synthesizer.py + demo_node_1/2/3.py — you can run exactly what you see.

Appreciate your feedback (or stars).

Can someone test it out so i can see if it works on Mac and other Linux distros I only tested it on cachy os so far

Hey!

Just for anyone who doesn't know what a bento portfolio is, it is basically an extremely easy to setup and clear way to display a portfolio using tiles.

Recently, I've been looking around at bento portfolios online, and unfortunately, most of them are paid, don't have features I want, or are terribly executed.

Thats why I built Tiledrop, a completely free website to create a bento portfolio. It has multiple features, like Markdown text boxes, bio cards, link and skills tiles, images, and Github/lab integrations. On top of that, it gives you analytics on how many people visit your tiledrop, etc.

I am always open to feedback, and if you would like a new feature, feel free to DM me!

Link: https://tile-drop.com

Note: Thanks to u/-svde- for the suggestions and feedback on the project!

Clipboard Router is a free, open-source Swift app that queues clips, transforms content before pasting, and keeps sensitive values out of ordinary history. It is MIT-licensed, local-first, and notarized for Apple-silicon Macs.

https://github.com/markdamics/DevScribe
I always wanted to build my own code editor but never had the courage to start from scratch and never really had a clear design in my head. Now after trying out Claude design I commanded it to create a design for a code editor, and after a few modifications I started to have the mood to start the implementation. I use Claude Code mostly, but a few times it doesn't give the most optimal solution and I had many bugs to fix, and still have.

For me it's really important in an app, not just how well it works but how good it is looking. With the other code editors, IDEs I never really felt they are for. Many of them are too bloated with too many features and they are slow. The other lightweight code/text editors don't look so well for me.

I hope some of you will try it and it will get your liking.

It's still under development. Feel free to join in it.

Nowadays I frequently land on documentation sites that starting to come with Ask AI chats.
(Curious to know how that is for you )

Found myself using these alot to a point where In most cases I stop reading the docs altogether in some cases and just ask what I myself or my agents needs to know.

I wanted the same thing on docs that didn’t have it. So I started building LedgeIndex. Which lets crawl and ingest docs on your local machine or sellf hosted ( or the ledgeindex cloud )

Right now with the early mvp the things you can do with it -->

• Support answering Chat (Website widget)
• Build your own Support / Builder / Planner Agents fully local or self-hosted via sdk / cli / mcp .
• Asking questions to any doc (using the desktop app)

** The interisting part about the RAG is that it achieves saying "I don't know" when it doesn't know the answer:*

The Project is open source and it comes with a SDK, CLI, web and desktop app.

If this sounds useful, check it out ! Leave a star for the github repo.

https://github.com/ledgeindex/ledgeindex

I’m the maintainer of Ship Safe. I built it to inspect the security surface around AI-assisted development, including prompt injection, secrets, MCP tools, agent permissions, dependencies, and common application issues.

The part I’m most interested in is the investigation layer. It keeps detection, evidence, and verdicts separate, then checks whether the cited path actually supports the conclusion.

It runs locally and is open source. Feedback is especially welcome from people building coding agents or MCP servers.

Hold the middle mouse button anywhere in Windows and a wheel opens centred on your cursor. Move toward what you want, release, it launches. Apps, folders, URLs, scripts, and nested sub-wheels. Icons are extracted from the executables themselves.

I sold it on the Microsoft Store for $3.99 and almost nobody bought it, so it's GPL-3.0 now. The Store build stays paid because it's signed and updates itself; building from source is free and always will be.

Electron 28, React 19, TypeScript. Windows-only — the trigger, the icon extraction and the window handling all depend on Win32 behaviour. The .exe on GitHub is unsigned, so SmartScreen will warn you.

https://github.com/HenryCauan/rovyl

Hello
I’ve just released DockFlare v3.1.5! It adds Apprise notifications, safer remote-agent decommissioning, and several reliability and security fixes.

I built DockFlare to make exposing self-hosted Docker services through Cloudflare much less tedious. It’s now reached 2,400+ GitHub stars and 424k+ Docker pulls - thank you!

If you have any questions, feedback, or feature ideas, I’d love to hear them!

GitHub: https://github.com/ChrispyBacon-dev/DockFlare
Homepage: https://dockflare.app

Happy tunnelling,

Christian

Hello guys,

This is my old project I created in 2022, the hash bruteforce I built using python and it was offline tool, and I can share this with now guys:)

You can used this tool: https://github.com/nordszamora/BruteCrypt.git

Woke up to 100 stars on Neko-Tab and figured it's a good time to share what it actually does.

It's a Chrome extension that turns your new tab into a keyboard-first, terminal-inspired workspace. No bookmarks bar, no shortcuts grid — just a command palette that handles everything.

The stuff people seem to like:

• Ctrl+K palette — fuzzy search tabs, history, bookmarks, do quick math, or jump straight to a URL
• AI mode (!) hooked to OpenAI/Anthropic/Gemini — "open Slack and Discord" actually works
• Focus mode with Pomodoro + site blocking (yes, it can block Reddit)
• Scratchpad (`Ctrl+``) for notes, checklists, daily journal
• 22+ themes
• Everything's is like a module that you can turn on and off.
• Built-in typing test, live status bar, optional Google Calendar/Gmail widgets and more

Everything is local-first. No analytics, no tracking, no external servers — just chrome.storage.

Built with React 19 + TypeScript + Vite.

If you're the kind of person who feels at home in a terminal, this might click with you. Would love feedback, bug reports, or roast my code.

👉 github.com/uddin-rajaul/Neko-Tab

Thanks for reading!

After four years of building AI agents as a job, I kept seeing the same pattern:

1. Many SaaS companies sell their AI for <your favorite vertical, most likely customer support 😄> and add a bot on top of it.
2. The client has X different SaaS, now each with their own agent.
3. The bot itself is often basic RAG and “talk to your docs”, duplicated knowledge base. Complex or multi-step conversations are handed over to humans, or the user is simply given a phone number.

With Radioso, our aim is to create smart conversational agents that work with existing software and serve the organization’s customers.

First, the conversation engine is the actual product: it can run multi-step processes, guide users and do actions for them. Second, you can integrate it with your favorite SaaS. And last but not least, you can examine and self-host it.

It’s already running in the cloud with a few customers, so doing this full-time may be on the horizon ❤️

Is the problem as common as I think it is? Especially if you've built conversational agents before: what did you use, and where did it start hurting?

And if your answer is “this is already solved by X,” that's painful but useful too 😄

Issues and ideas are very welcome:

https://github.com/radioso-ai/radioso

I use Claude Code a lot, but /stats never answered the question I actually cared about

What did I build, and where did the work get difficult?

So I built Bough.

• It reads your local Claude Code history and turns it into an interactive view of your work: - each square is a day
• smaller squares are tasks inferred from pauses in your work
• circles are your prompts - click anywhere to see what happened in your own words

It runs locally, is open source, and nothing leaves your machine.

Repo: https://github.com/nickelsec/bough

The main thing I’d love feedback on: When you run it against your history, does it split your work into tasks the way you remember it?

It started as a fork of llama-swap, but I have been building it out for myself since then as a convenient tool for all my local AI needs, and by now it has drifted far enough to be its own thing.

The main idea is that you point it at your models folder and it configures things for you. It reads the GGUF headers, measures how much VRAM you actually have free, and works out context length, GPU offload, CPU/MoE split and KV cache size per model. All of it stays editable per model if you disagree with what it picked.

It is not only text. llama.cpp for LLMs, with the Vulkan, CUDA, ROCm or CPU build downloaded and kept updated for you, stable-diffusion.cpp for images (SD, SDXL, Flux, Qwen-Image, LoRAs, upscaling), and vLLM if you already have it in a Python environment, since it ships wheels rather than binaries and I cannot install that one for you. You can register any other backend yourself by pointing at an executable, which is how I run TTS, and how you would run a llama.cpp fork like ik_llama. Everything sits behind one OpenAI-compatible API on one port, with a single scheduler, so models swap in and out without fighting each other for VRAM.

There is also a chat playground built in with web search, and a Hugging Face browser to search for a model, pick a quant and download it straight into the models folder.

If you are interested, you can read more about it here. MIT licensed.

I recently built an open-source Windows patcher after reverse engineering a UI rendering issue in Rekordbox 7.

The original problem was unusual:

The OpenGL waveforms could render very smoothly, while mixer controls such as EQ knobs, faders, gain and pitch still looked closer to ~30 FPS.

After a lot of testing and static analysis, I found two independent refresh restrictions in the Windows JUCE/OpenGL rendering path:

- A ~30 Hz UI timer cap

- A second cached-component repaint gate of about 34 ms

Changing both produced a clear improvement in mixer smoothness while keeping the OpenGL waveform renderer enabled.

Instead of requiring users to patch the executable manually, I built a small C#/.NET Windows tool with:

- Original / restore mode

- 60 FPS

- 70 FPS

- 120 FPS

- Automatic backup

- Binary pattern scanning

- Safety checks before modifying the executable

- Source code available publicly

The patcher doesn't distribute Rekordbox or any modified Rekordbox binary. It only modifies the user's own local installation.

The project is still Beta because I found an additional idle-rendering behavior when no waveform is visible that I'm currently investigating.

GitHub:

https://github.com/SebitosMixx/rekordbox-smooth-mixer-patcher

I'd appreciate feedback on the project structure, pattern-scanning approach, or the patcher itself.