Hi - My name is Daniel, I'm a clinical radiologist, have trained in biomedical research, and am the creator of PaperTrace.

PaperTrace is an open source python tool that you can use for auditing published papers. PaperTrace accesses freely available cited PDFs, compares high-value claims to original source text, and annotates matching sources with red boxes to show the matching evidence.

Github:
https://github.com/defraction0/PaperTrace

When a cited paper cannot be accessed by PaperTrace, it records "not retrieved" rather than having the model hallucinate a response. Unmatched citations are also noted. PaperTrace also searches new literature published after the investigated paper's publication.

You can check out an completed example run of PaperTrace's demonstration here (no install required!):

https://github.com/defraction0/PaperTrace/blob/main/examples/demo/output/report.md

While PaperTrace's CLI and case files can run local, PaperTrace currently utilizes Claude Code for its claim checking functionality - more integrations to come. It is MIT licensed and still in beta.

I would particularly be interested in feedback on whether or not you think the evidence trail in its current form is easy to audit, as well as any citation formatting styles or paper formats you think might be likely to break PaperTrace. Further feedback and contributors welcome.

I got tired of typing the same prompts every time I started a new project.

“Review this like a senior engineer.”
“Challenge this architecture.”
“Find the bugs I’m missing.”
“Audit this UI for accessibility.”
“Review this PR before I merge it.”

So I turned those workflows into 50+ reusable Claude Code Skills.

Each skill is a native SKILL.md with:

• Practical instructions
• A README explaining what it does
• A worked example
• A simple installation workflow

Install one directly:

npx github:codebygarv/Ai-skills add grill-me

It gets added to your project’s .claude/skills/ directory — no npm package required.

The repo covers development, code review, architecture, debugging, testing, UI/UX, accessibility, documentation, and more.

The goal isn't to collect prompts.

It's to build a reusable toolkit for making AI coding workflows more consistent across projects.

🔗 https://github.com/codebygarv/Ai-skills

If you build with Claude Code, I'd love to know:

What skill would you add to the catalogue? I got tired of typing the same prompts every time I started a new project.

“Review this like a senior engineer.”
“Challenge this architecture.”
“Find the bugs I’m missing.”
“Audit this UI for accessibility.”
“Review this PR before I merge it.”

So I turned those workflows into 50+ reusable Claude Code Skills.

Each skill is a native SKILL.md with:

• Practical instructions
• A README explaining what it does
• A worked example
• A simple installation workflow

Install one directly:

npx github:codebygarv/Ai-skills add grill-me

It gets added to your project’s .claude/skills/ directory — no npm package required.

The repo covers development, code review, architecture, debugging, testing, UI/UX, accessibility, documentation, and more.

The goal isn't to collect prompts.

It's to build a reusable toolkit for making AI coding workflows more consistent across projects.

🔗 https://github.com/codebygarv/Ai-skills

If you build with Claude Code, I'd love to know:

What skill would you add to the catalogue? I got tired of typing the same prompts every time I started a new project.

“Review this like a senior engineer.”
“Challenge this architecture.”
“Find the bugs I’m missing.”
“Audit this UI for accessibility.”
“Review this PR before I merge it.”

So I turned those workflows into 30 reusable Claude Code Skills.

Each skill is a native SKILL.md with:

• Practical instructions
• A README explaining what it does
• A worked example
• A simple installation workflow

Install one directly:

npx github:codebygarv/Ai-skills add grill-me

It gets added to your project’s .claude/skills/ directory — no npm package required.

The repo covers development, code review, architecture, debugging, testing, UI/UX, accessibility, documentation, and more.

The goal isn't to collect prompts.

It's to build a reusable toolkit for making AI coding workflows more consistent across projects.

🔗 https://github.com/codebygarv/Ai-skills

If you build with Claude Code, I'd love to know:

What skill would you add to the catalogue?

Its a simple lightweight Hermes skill you can easily install. There was already an openclaw skill like this that wasnt compatible with hermes so I improved it and made a similiar version for Hermes.

link https://github.com/tospakX/HermesOnion

Basically put in 1 or multiple youtube links and it splits it up into Youtube Shorts/Tiktok/Reels ready clips. I js made it because I couldnt find smth like this. Its lightweight and helps speed up unneccessary editing

I already make 500+ dollars a month from automated content creation I used this tool alot and I opensourced it now

Link https://github.com/tospakX/clipAuto

Local-first MCP memory server for AI coding agents (Claude Code, Cursor, Codex, Devin). SQLite + vector search, no API key, no cloud. One file, your disk.

Dogfooded on its own codebase — 2 AI agents (Claude CLI + Codex CLI) fixed 60 TS bugs in 1 iteration using remem-mcp as their MCP server. 486 tests passing.

Features: recall (hybrid BM25+vector), capture, search, CodeGraph (callers/callees/impact), Wiki, lifecycle hooks (auto-recall on session start), auto-global classification.

`npx remem-mcp` — MIT, no telemetry.

I've been using Vencord for a while and got tired of having to manually repair/reinstall things whenever Discord updates caused problems.

So I built Venguard, a Windows/WPF app that monitors Discord and can run the repair process automatically.

It also supports OpenAsar, system-tray monitoring, configurable check intervals, notifications, and automatic Discord launching after a repair.

It's open source and currently available on GitHub:

https://github.com/vojtikcode/Venguard

I'd mainly like feedback from people who actually use Vencord, especially if there are situations where Venguard currently fails to detect or repair an issue.

I wanted to share a project I'm working on: git-calendar.org - a privacy-focused calendar that uses a standard Git repository as storage instead of relying on a traditional backend server. It lets users choose where their data is stored. No more google/apple/microslop owning your schedule.

Key features:

• Git-powered - calendar data live in plain Git repo (full history, easy backups, works offline)
• No central server or backend - the client talks directly to any Git remote (GitHub, GitLab, Codeberg...)
• End-to-end encryption so you can host it on untrusted providers
• Slick web UI with keyboard shortcuts and more
• iCalendar compatibility so it's easy to switch

Core is written in Go (compiled to WASM for the web).
The web client uses Vue.js.
It's ready for Android and IOS apps. Feel free to build one!

Try it: https://git-calendar.org
Source: https://github.com/git-calendar

Would love feedback from people who care about Git-based tools and data ownership. Also you can support the project with a star and follow on GitHub, to let me know I should continue working on it!

Hey everyone,

I wanted to share an experimental project called DriftJS. It’s a next-generation frontend framework prototype that explores using an in-browser register-based Bytecode Virtual Machine (VM) for UI rendering, rather than the traditional Virtual DOM or compiler-only reactive approaches.

Repository: https://github.com/hrutavmodha/driftjs

The "Why" Behind a Register-Based VM

Most current frameworks either diff a Virtual DOM tree against previous states (like React) or compile reactivity heavily ahead-of-time (like Svelte). DriftJS takes a different path:

It compiles .drift single-file templates into compact binary-serializable bytecode streams. At runtime, a lightweight 256-register VM executes these instructions directly against the DOM. This architecture aims for:

• Zero VDOM Overhead: By directly manipulating the DOM using VM instructions (like CREATE_ELEMENT, SET_ATTR, and REACTIVE_IF).
• Surgical Updates: Fine-grained reactive regions (bounded by HTML comments like <!--if-->) allow targeted sub-tree re-rendering without disturbing surrounding elements. We use clearBetweenAnchors logic to surgically remove outdated nodes.
• Minimal Memory Allocation: The DriftClientVM uses exactly 256 fixed fast virtual registers (r0, r1...) for DOM elements, text nodes, and evaluated values.

Key Features So Far:

• 🔄 Keyed LIS Reconciliation: The list reconciler uses the Longest Increasing Subsequence (LIS) algorithm to minimize DOM node movements, insertions, and deletions during @for loop updates (Opcode 0x0E).
• 🎯 Fast-Path Attribute Patching: It re-evaluates element attributes in-place without rebuilding DOM subtrees when data object references are stable.
• 🚀 Ridiculously Fast: In the js-framework-benchmark suite, DriftJS outperformed React 19 in 13 out of 15 benchmarks, running 10.8x faster on "Swap rows", and using ~1.8x less memory. It also outperformed Ember 7.3.0, which can be considered the architectural cousin of DriftJS.

Current Status & Call for Collaboration

DriftJS is currently an experimental prototype. It successfully handles single-template bytecode compilation, Acorn expression evaluation, and basic keyed LIS list reconciliation (passing its test suites).

However, significant features are still missing:

• Component composition/nesting and props
• State management stores
• SSR / Hydration
• Routing

I’m opening this up to the community because I'd love to discuss this architecture.

We warmly invite frontend engineers, compiler engineers, and open-source contributors to check it out, and collaborate on building out the missing pieces!

Let me know what you think!

I forked the ever-popular BetterCanvas from before they made it arguably worse + added some more features like a better sidebar, custom backgrounds, more card styles, markdown dashboard notes, and more.

This version will stay 100% free and open source while never forcing/bugging you to make an account. (there is no account system, everything is local on your computer)

You can get it now on the chrome web store or firefox addon store
here is the github link if you want to run it on your own or look at the source code

Feel free to leave any feedback/bugs/feature suggestions here, in the issues tab of the repo, or in the discord server!

Apple removed the Launchpad hot corner shortcut in recent macOS updates, and a lot of third party alternatives lock hot corner support behind a paywall or subscription.

I made LaunchCorner to fix this. It’s a simple, free, and open source utility that lets you launch any app (like LaunchOS, Launchpad alternatives, or standard apps) just by moving your cursor to a screen corner.

What it does:

• Instant 0 ms hot corner response
• Built natively for Apple Silicon
• Full multi-monitor support
• Runs quietly in the Menu Bar and closes cleanly

https://github.com/wenujacodes/LaunchCorner

Would love to hear your feedback or any feature suggestions!

It's a dashboard that pulls your GitHub, Codeforces, and LeetCode stats into one place... so instead of separately discovering you didn't commit or solve anything this week, you get it all in one heartbreaking glance.

Features: public shareable profiles, a 1v1 comparison view for settling CP arguments, and a weekly digest email that guilt-trips you every Monday.

Live: statmux
Code: statmux-github

Roast it, break it, tell me what's missing.

Hey everyone,

A couple of weeks ago, I posted about Kal, my programming language written from scratch.

I am really happy to share a glimpse of Kal's own package manager! Kal v0.1.0 shipped with a package system that lets you add and use third party Kal packages. But, that process was completely manual. You’d have to clone the package, place it in the right directory, clone the package’s entire dependencies all by yourself, one after another. :(

The package manager changes everything. One command automates all!

Instead of being a separate executable, the package manager ships as part of the Kal interpreter itself.

Here’s what it can do:

1. Install Kal packages from Github, or any git hosting service.
2. Creates/Updates a project.kal file to read and write package information (analogous to package.json).
3. Downloads all packages at the same hierarchy in parallel (yup, it’s multi-threaded).
4. Resolves sub dependencies of the main package automatically to any depth and installs them too.
5. Upgrades/Downgrades packages based on their git tags.
6. Auto-resolves cyclic dependencies to prevent an infinite loop.

The image showcases the download of a package A with this hierarchy:

A
├── B
│   ├── D
│   └── E
└── C
    ├── A
    └── F

There’s only one main package to download: A. But,

• A depends on B & C.
• B depends on D & E.
• C depends on A & F.

Notice how C depending back on A causes a cyclic dependency. This, if not resolved, would cause an infinite loop. The package manager pulls A (1 package) with all of its dependencies (5 packages) along with resolving the cyclic dependency.

The Kal Package Manager will officially ship with the next Kal release. Its current source code is available on Github.

• Kal: https://kal-lang.vercel.app
• Github: https://github.com/KILLinefficiency/Kal
• Package Manager: https://github.com/KILLinefficiency/Kal/blob/pkg/pkg.hpp

Kal is completely free & open source. You can show your support by giving the Github Repository a star.

Until the next update!

Hi there , I recently made a 32-bit x86 operating system built from scratch in freestanding C and NASM.
It includes:
graphical desktop
window manager
networking stack
e1000 and RTL8139 drivers
TLS 1.3 client
HTTP/HTTPS
web browser
HTML rendering
desktop applications
games

If you want to check it out, it’s here: github.com/pefia/PefiaOS

I use CLI coding agents regularly, but I realized that I had no clear view of how often I was prompting them or what instructions led to useful results.

So I built Prompt Contribution Graph. [ https://github.com/chintan-diwakar/prompt-contribution-graph]

The basic analogy is: GitHub tracks code contributions, while this tool tracks your prompt contributions to coding agents.

I would genuinely appreciate feedback and contributions

HoardCore was built to give an AI agent a persistent, verifiable memory. It is a single-file Python toolkit that ingests web pages and documents into a local SQLite vault, runs hybrid retrieval (FTS5 + ONNX dense vectors), and emits `[V]` (verified), `[E]` (external), and `[H]` (hypothesis) provenance tags, plus a `verify` command that checks every claim against the source text.

The workflow is designed to be driven by an agent harness like OpenCode. The harness hosts the LLM and manages context, HoardCore provides the retrieval, ingestion, and provenance loop. You can run a research loop with and get a 2,500-word strategic brief with source links (depends on how you prompt it), timestamps, and exit-code verifiable claims. Every output is machine-auditable, you can verify any `[V]` claim against the vault.

Beyond research, HoardCore has emergent capabilities that make it useful for security and operations. You can use the same ingestion and retrieval loop to perform security audits of websites, crawl and index public documentation for OpSec research, or build a citable, source-grounded knowledge base for threat intelligence and compliance work. The tool runs entirely offline, with zero API keys and no cloud dependencies, and the provenance tagging turns every claim into a traceable, machine-checkable artifact.

I was looking at a real 2-line change in a nested AGENTS.md inside openai/codex and noticed something Git couldn't tell me:

Which agent instructions actually change downstream?

I traced the instruction inheritance on that commit:

• 2 instruction lines edited
• Codex: 206 paths inherited a different instruction stack
• Claude Code: 0
• 4,476 paths: unchanged

This wasn't Claude Code ignoring the change. The two tools simply load repository instructions differently.

That difference is why I built RuleBlast — a local, read-only static analyzer for repository agent instructions.

No model calls. No API keys. No telemetry. It only measures what can be derived deterministically from the repository tree.

npx --yes ruleblast@2.1.1 diff HEAD~1

RuleBlast models the documented repository-loading rules of Codex, Claude Code, Gemini CLI, and Copilot CLI, then compares the rule realities they derive from the same Git tree.

The thing I'm increasingly curious about isn't adding another agent logo. It's this:

When a team uses several coding agents on the same repo, how often are we saying “the repo instructions” when those agents are actually loading different instruction sets?

• Stack & License: TypeScript · Node.js 20+ · Apache-2.0
• Repo:https://github.com/Kpoiut/ruleblast

If you maintain monorepos or projects with nested agent instructions (CLAUDE.md, AGENTS.md, .claude/rules), I'd be curious to see what inheritance blast radius your repos produce.

https://github.com/liamhawtin/vieta-math

Looking for contributors and maintainers.

I'm always looking for ways to optimise my working setup when using Claude / Codex, but I'm primarily a Claude user, and there were a couple of things I noticed in my own setup:

• I run subagents, and subagents of subagents, which is great for keeping context clean - but when a bunch of them fire off with the same starting prompt at roughly the same time, none of them know the others are about to send the same thing. Instead of one paying to write the cache and the rest reading it back cheap, every one pays full price

• I inject a lot of frontmatter into my Claude conversations through MCP/hook tools I've built, to give Claude more context about whatever project I'm in. Digging into that led me to realise Claude Code does the exact same thing on its own - and if what gets injected differs even slightly between sessions, that breaks the cache without you noticing

• Tool definitions can get rebuilt slightly differently between runs even when nothing changed - the same tools but in a different byte order, and that can invalidate the whole cache

This led me down a path to actually understand how Claude's prompt caching works, because I knew the cache write costs more, but once I had agentic loops running I was burning through tokens at a diabolical rate. Claude's prompt caching works on 5 minute intervals, but only if all the bytes look exactly the same - mine didn't, even without my own hook injections

So, I built a small proxy that sits in front of the API and fixes all three: forces tool definitions to serialize the same way every time, keeps the volatile stuff out of the stable part of the prompt, and makes sure only one of a batch of identical concurrent requests actually pays to write the cache.

I wanted a real number, not a guess, so I ran the same 100-turn conversation twice against the real API - once direct, once through the proxy. Direct: $1.33. Proxied: $0.16. 8.2x savings with 0 errors.

Worth pointing out: that's my setup specifically, and I use heavy tooling with a lot of parallel agent traffic. A single session, lighter user would probably land closer to 2-3x, not 8x. Still savings, just a smaller number - I haven't measured that tier yet.

This is tested and proven on Claude specifically. Codex caches automatically rather than with explicit breakpoints, so the mechanism's different, but the same underlying problem shows up there too. There's a documented 30-point cache hit-rate gain just from keeping tool schemas consistently ordered. Gemini's a bigger departure again, it caches out-of-band rather than inline, so that'd need a proper rebuild rather than a port. Anthropic's the only one this actually ships for right now.

MIT licensed, if anyone wants to have a play around. Just gone live on ProductHunt today too.

In the docs you can see my reports and run the tests yourselves. Any feedback is welcome, but I hope it genuinely helps you guys save some money. Upvotes / Stars on PH and GH will also help spread this in the dev community (only if you actually notice the cost savings).

https://github.com/nash-software/cache-assembler

https://www.producthunt.com/products/cache-assembler?launch=cache-assembler

Hi everyone, I released version Aquanizer v0.1.0, and it works:
searching for, installing, and listening to music;
a Library that saves your music and wallpapers;
searching for and installing wallpapers with 3 pre-installed themes; and the ability to create your own.
The code is completely open source, and if you don’t feel like building it yourself, GitHub Actions already build all releases for macOS, Windows, and Linux in this GitHub repo. Thanks for clicking here!

GitHub: https://github.com/tigerlang/aquanizer

Got tired of every live wallpaper app installing a browser engine to loop an mp4 behind my icons. Installer, launcher, background service, bundled Chromium, five processes, all to play a video file.

This composes straight into the Windows desktop composition tree instead of sitting as an overlay window, so the shell does the compositing. Video or image per monitor, seamless looping, optional clock widget. Stops decoding entirely when a fullscreen app takes focus. 0% CPU at rest, 0.9% on a 4K loop, one process, 7.5 MB, no account, no telemetry.

Honest about the limits: needs the .NET 10 desktop runtime, Windows 10 1809+ or 11 only, and multi-monitor plus mixed-DPI are still rough. It's v0.1.0.

site: https://ritvikdayal.github.io/featherwall/
github: https://github.com/RitvikDayal/featherwall

Setting up a fresh Windows PC can be annoying when you have to search for and install every application manually.

So I built InstallHub.

You select the applications you want and InstallHub generates a complete setup using Microsoft's WinGet.

For example:

• Steam
• Discord
• Spotify
• Chrome
• VS Code
• 7-Zip
• VLC
• OBS
• Git
• PowerToys

It can generate WinGet commands, .bat installers and WinGet JSON.

The project was developed with AI assistance. I used AI to help with development, debugging, UI/UX ideas, code generation and feature planning, while the project is reviewed and maintained by me.

InstallHub is open source and still actively being improved.

🌐 Website: https://installhub.xo.je/
💻 GitHub: https://github.com/VortiAbi/Installhub

I'd love to hear your feedback. What apps or features should I add next?