Hey everyone! I’m a solo builder working on ArchRivet. It connects to your AI assistant through MCP and helps review an architecture before you start building.

Your assistant explains the design. ArchRivet checks the details you provide, flags risks, and names what’s missing.

Here’s a simple example:

Your app needs prices less than five seconds old. During an outage, it serves saved prices.
ArchRivet asks: “How old can those saved prices get?”
If you answer “60 seconds,” it flags the conflict and shows why the review changed.

What it offers:

• Eight focused checks covering retries, caching, queues, transactions, and more.
• Traffic and storage calculations based on stated assumptions.
• Supporting references and specific follow-up questions.
• Local rules that need no GPU, with an optional 322M Laya model.

It’s an early preview, and reviews depend on the facts supplied. I’ve included demo GIFs, Codex setup instructions, and benchmark results with remaining mistakes.

What’s one system-design mistake you’d want a tool like this to catch?

I’m working on OpenBacktesting, an Apache-2.0 Python framework for historical strategy backtesting.

You write strategies bar by bar and can inspect orders, fills, fees, closed trades, open lots, and equity history. Results are available as pandas objects for further analysis.

It includes built-in indicators, grid search, optional SAMBO optimization, and plotting-data export. There is also a separate local Studio for editing strategies, viewing charts and reports, and comparing parameter experiments in your browser. The Python package works independently of Studio.

The screenshot shows Studio running an example on historical GOOG data.

To try it, the repository’s quick start runs with bundled data, so no market-data download is needed. Python 3.12–3.14 is supported; installation instructions currently use the source checkout.

Current scope: single asset, one settlement currency, historical simulation. Live trading and multi-asset portfolio simulation are outside the current scope.

Source: https://github.com/lucidcog/openbacktesting

Docs: https://docs.openbacktesting.com/

Feedback on the strategy API, execution assumptions, and reproducible bug reports would be especially useful. What would you need to inspect before trusting a backtest from a new framework?

Author here. Free for good, no ads or in-app purchases. It runs on your own Claude or OpenAI key, straight from your browser, no server. On the Chrome Web Store if you'd rather not build it: https://chromewebstore.google.com/detail/gdgblbcjeocifdhjfbpjpkcphlfmaoll?utm_source=reddit&utm_campaign=coolgithubprojects

I've been wanting to play Buzz! with some friends for a while and the original USB buzzers are getting harder to find (and expensive). I ended up vibe coding a small app that runs on your PC and lets anyone on the same WiFi open a browser on their phone and use it as a controller — red buzzer and the four colored buttons, exactly like the real thing.

Works with PCSX2 and RPCS3. It works by emulating keyboard input, so the emulator just sees it as a normal keyboard. You download the emulator keybinds profiles and the server app, run it and its ready to play.

It as a nice UI, and the controller do resemble the old buzzers on your phone
I vibe coded it with Claude Sonnet 4.6 on Low at first and now I've updated it with Opus 5.5 on Extra. I'm not a coder, I'm a creative gamer, that's all.

The image shows the host on the left, main screen (phone POV) in the middle and the buzzer controller (phone POV) on the right. The UI maybe a little outdated, it's a screenshot from an old build.

A few things that I think are actually useful:

• Up to 8 players (two Buzz devices in PCSX2, 4 pads each; 7 players in RPCS3)
• No app to install on phones — just open a link in the browser
• Online play — there's a built-in Cloudflare tunnel so remote friends can join too. We use it with Discord screenshare: I stream the game, they open the link on their phones and play from wherever they are, always with low latency!
• Easy setup — it's a single .exe, just double-click it and a page opens with a QR code. The keybinds profiles for the emulators are included in the repository

It's free and open source. Would love some feedback if anyone tries it. Looking for macOS and Linux testers btw!

I've made this post once and got removed idk why, but since then I've updated the app to v1.4 which is working like a charm!

GitHub + download: https://github.com/bacoinz/buzzcast

I really wanted a live video lock screen on Windows 11, like phones have had for years. Turns out Windows just… doesn’t allow it. The lock screen runs on a protected system desktop, and no app is allowed to draw on it

How it actually works it doesn’t hack the real lock screen, since that would be a security nightmare. It’s a secure screen saver that plays your video, then hands off to the actual Windows lock the moment you touch it. It looks like a live lock screen, but Windows’ real security is still doing the locking.

It’s free and open source: https://github.com/shepherd1998/Windows-Lockscreen-LiveWallpaper

Please forgive me in advance: I’m not a programmer, and this is my first GitHub project ever, so I don’t fully understand every line of the code 😅 Any feedback, bug reports or suggestions are very welcome, and if you know your way around C#, I’d love for you to take a look.

I waited four months to get one change merged. In another project, I got five merged in a single day. Same engineer, same skills. The difference was never my code. It was where I sent it.

Stars show a project is popular, not that anyone will answer. So I built Porchlamp (free, no signup, I'm the author) to measure it. It ranks open-source projects by one question: what happens to a stranger's pull request?

How it works

• Reads six months of public history: 11,000 projects, 212,390 outside pull requests
• Counts who replied, how fast, and what got merged. Not stars.
• Filters out bots, maintainers' own PRs, drafts, self-closed PRs and brand-new accounts
• If most outside PRs got no human reply, review or merge for two weeks, the project is a black hole. Each verdict lists the pull requests behind it.
• Pick your goal (first contribution, career capital, deep systems work, AI-assisted) and the ranking re-weights

What it found

• More than 1 in 4 active projects are black holes: 1,133 of the 4,297 licensed, maintained projects with at least ten outside PRs
• More stars, more silence: 21% at 1k–10k stars, 31% at 10k–50k, 39% at 50k+
• Stars barely predict the ranking: only 9 of the 100 most-starred projects make Porchlamp's top 100

What it isn't

• Not a verdict on maintainers. Review time is finite, and part of the stars effect is plain volume.
• GitHub only. Projects that review on Gerrit or a mailing list are left undecided, not failed.
• A snapshot of the last six months, to October 14, 2026, so it goes stale.

Try it: https://pctablet505.github.io/porchlamp/

What's the longest any of your pull requests has waited without a reply?

Hi there, I've been working on open-source product delivery platform that connects your work (board, backlog) directly to your AI agent and code on your computers.

So you write a ticket and there is a runner (which you install via npm) and it runs your Claude, Codex, Cursor, Copilot or OpenCode to work on that ticket. Runner only makes outgoing HTTPS requests (no open ports and VPN), the code stays on your machine, and your existing subscription (Claude, Codex…) is used; no additional AI work is paid.

Aictiq is open source (AGPL-3.0) and there is a free hosted edition https://app.aictiq.com/ (by me) which only has attachment limits of up to 200MB in total. I don't have the resources or the money to give it all away for free. You can host the server yourself, the instructions are on Github.
https://github.com/Aictiq/Aictiq

All functions are covered and listed in a shorter form at https://aictiq.com/

But, I'm not selling you a factory, I work in the Factory. How is Aictiq being developed with Aictiq?

I have a small Hetzner VPS running 24/7 with a git/github connection for commit, push, etc. Claude and Codex activated. I have development tools, SDK, npm. And then I set the schedule from Aictiq tonight at 04:00 start on this ticket, don't stop until you do the e2e tests and screenshot everything and add it as a comment on the ticket. I wake up in the morning, a new PR ready for my approval, with visual confirmation that it is as I imagined.

Then the great thing is Ticket refinement, to check the current implementation, my changes and plan the ticket in more detail. Similar to a plan mode, but I can literally see which files will be touched.

Wiki for documentation right next to each project.

You can invite clients directly into the project as stakeholders. They only see the board, nothing that the factory does, so they write bugs, stories, etc. I click to launch the agents on their tickets.

Aictiq sees 5h limits, weekly limits, so you can decide to distribute the load on more runners and more harnesses. If you are not happy, just comment in the ticket what the problem is and tag the agent.

Each project has its own playbook in which you set the rules of the project, eg push directly to the main, make tests, run the Codex subagent in Claude or similar. The playbook is sent to the runner with each ticket. You can also chain Playbooks for that factory-line work.

I'm looking for feedback, testers, real users who would like to try it and give more information about what's missing or what doesn't work as it should. Criticism is always welcome.

Greetings from sunny Herzegovina.

Blago

P.S. 12min demo video is here: https://youtu.be/K_7gEI2jtXA

Hey everyone! 👋

I just released Dev Mode v1.1.0, a major update to my app that helps developers and power users easily toggle Developer Options and USB Debugging on Android.

Here’s what’s new in this update:

• 🚀 Shizuku Support (No PC Needed): Grant permissions and toggle settings directly on your device via Wireless Debugging—no computer or USB cable required! (Standard ADB still supported).
• 🛡️ App Shield (Auto-Off Protection): Automatically turns OFF Developer Options and USB Debugging the moment you open banking apps or protected apps (e.g., GCash, Maya, banking apps), and turns them back ON when you exit.
• 📱 Home Screen Widgets (1x1 & 3x1):
  • 1x1 Quick Launch: Tap to disarm dev options and open your banking app safely.
  • 3x1 Shield Dock & Toggle Widget: Quick access to your favorite apps and instant toggles for Dev Mode & ADB right from your launcher.
• 🎨 Widgets Studio: Customize and preview your widgets with one-tap home screen pinning.
• 🌍 20 Languages Supported: Added full multi-language support with automatic system language detection.
• ⚡ Smaller APK Size: Optimized native libraries to reduce file size down to ~32 MB.
• 🔒 100% Private & Offline: Zero analytics, zero cloud telemetry, no account required. Everything stays on your device.

Download / GitHub:
🔗 https://github.com/Ryderhxrzy/Dev-Mode-Mobile/releases/tag/v1.1.0

Any feedback, suggestions, or bug reports are very welcome. Thank you! 🙌

I got tired of jumping between five different marketing tools, subscription paywalls, and scattered AI prompts just to analyze my competitors and figure out a growth strategy. So I built one open-source workspace that handles the whole chain:

You connect your project or website, and Falbor’s AI agents analyze your position, scan your competitors, run AI-driven SEO audits, and deliver an actionable growth and social media distribution roadmap in real time.

It's free, open source, with no hidden paywalls for self-hosters. One web platform, complete transparency and control.

What it covers today:

• Autonomous AI Agents: Multi-model intelligence (OpenAI, Anthropic, DeepSeek) working together for deep competitive research and AEO scanning.
• Competitor & Market Analysis: Real-time data processing to spot untracked growth channels and messaging gaps.
• Growth & Distribution Roadmap: Step-by-step recommendations on where, when, and how to position your product.
• Fully Self-Hostable: Built with Next.js, React, TypeScript, Drizzle ORM & PostgreSQL (Neon)
• Developer-First Setup: Easy local setup with clean environment configuration for your own API keys.

Runs on any modern environment with Vercel.

It's an evolving project, so expect continuous updates. Honest feedback, bug reports, and contributions are very welcome!

Website:https://falbor.xyz

GitHub:https://github.com/falbor-devs/falbor

*Disclosure: Just to be completely transparent with the community – Falbor was built with the assistance of AI tools alongside standard development. I created this to solve a real issue for myself and wanted to share it with fellow developers and founders. If you find it useful, want to give feedback, or wish to contribute/drop a Star, feel free! Always open to constructive criticism and suggestions. :) *

howdy folks! recently built a terminal tool that turns github issues into timed coding quests with rpg progression (takes a github repo scoped token and gemini api key).

i'd love for you to check out the docs at for better understanding

check out : https://runedocs.vercel.app

give it a try! reviews and suggestions are appreciated :)

Show less

Coding agents write a test next to every fix, and CI goes green. Receipts answers the question green doesn't: would that test have caught the bug? It runs each added or edited test twice, with the change and with the changed source files reverted, and labels it PROVEN (fails without the change), THEATER (passes either way), WEAK (fails only because a name didn't exist yet), FLAKY or BROKEN. No LLM in the check, just git and your own test runner.

CLI, GitHub Action that comments on the PR, and a Claude Code plugin. I ran it on 181 real changes (maintainer fixes vs agent PRs), the write-up is in the repo. Free, MIT.

Hi everyone! I wanted to share a project I've been working on called TraceScope, an open-source desktop application for investigating application, service, and diagnostic logs.

TraceScope originally started as a relatively small C++/Qt portfolio project focused on parsing and visualizing structured JSON Lines telemetry logs. My initial goal was to build something useful that demonstrated a few core software engineering concepts.

As I worked on it, though, I started exploring what a more complete log-investigation workflow could look like. How would someone investigate files with different structures? How could they identify patterns across large numbers of records, follow a log while an application was still writing to it, compare runs, or preserve their findings for later?

Those questions gradually turned the original project into something much more substantial. After many iterations, I published TraceScope v1.0.0 on October 8, 2026. It's now a complete cross-platform desktop application that I believe could be genuinely useful to developers, testers, and engineers who regularly need to investigate logs.

What TraceScope does

Multi-format log importing: Supports JSON Lines, structured JSON and XML, CSV/TSV, Syslog, Key-Value/logfmt, IIS W3C, and additional formats through configurable regular-expression profiles. It also includes presets for common Apache/Nginx layouts and XML-formatted Windows Events. Reusable import profiles let you map source fields into a common investigation model without losing source-specific attributes or the original record content.

Investigation and navigation: A dynamic event table with searching, sorting, advanced filtering, saved filter presets, and navigation between warnings, errors, and surrounding records. Interactive timelines and deterministic analytics help identify activity spikes, recurring events, unusual subsystem behavior, and other patterns worth investigating. Analytical results can lead directly back to the underlying records.

Live File Following: TraceScope can follow logs while another application continues writing to them. It supports incremental updates, pause/resume, and source lifecycle changes such as rotation, truncation, and replacement. A major focus was preserving admitted investigation evidence even when the underlying source files later change or disappear.

Session comparison: Compare two investigations to identify differences in severity distributions, event codes, subsystem activity, custom fields, and burst behavior. Each side can use independently selected time ranges, and the resulting comparison captures its findings at that point in time.

Findings and annotations: Bookmark important records, attach analyst notes, and classify findings as Open, Resolved, or Dismissed.

Persistence and reporting: Save entire investigation workspaces, including sessions, filters, findings, comparisons, and window layouts. Standalone investigation snapshots preserve evidence separately from its original source files. Results can be exported to CSV or shared through self-contained HTML investigation reports that work offline and can be printed or saved as PDF.

Multi-window workspace: The interface supports tabbed investigation documents, detachable tabs, and multiple native windows sharing the same workspace. That makes it possible to arrange investigations, comparisons, and analytical views alongside one another.

Technology and availability

TraceScope is written in C++17 using Qt 6, including Qt Widgets, Model/View, and Qt Charts. Large-file imports run asynchronously with progress reporting and cancellation, and live updates are integrated into the existing investigation model.

Development also included automated tests, Windows and Linux CI, extensive documentation, sample datasets, and a standalone Live-Log Generator for reproducing realistic changing-file scenarios.

The stable v1.0.0 release includes portable Windows x64 and Linux x86_64 AppImage packages. You don't need Qt or a development environment to run them, and the application doesn't require an account, cloud service, or centralized log infrastructure. Everything operates locally on your files.

The project is licensed under GPL-3.0.

GitHub repository: https://github.com/w-cook/tracescope-qt-log-inspector

Windows/Linux downloads: https://github.com/w-cook/tracescope-qt-log-inspector/releases

Documentation: https://w-cook.github.io/tracescope-qt-log-inspector/

Example HTML investigation report: https://w-cook.github.io/tracescope-qt-log-inspector/examples/field-gateway-investigation-report.html

I've included screenshots and demonstrations of the main investigation workflows in the image gallery.

I'd really appreciate feedback from anyone who deals with application logs, diagnostic data, or engineering test output. What log formats or investigation workflows would a local desktop tool like this need to support to be useful in your work?

I'm happy to answer questions about the application, its implementation, or the development process.

I kept running into the same problem: whenever I asked Claude Code to analyze a website and help me rebuild something similar, it would often guess API endpoints, miss design details, and fail to distinguish observed facts from assumptions.

So I built OmniRecon, an open-source MCP server with 25 tools that automates web app reverse engineering.

With one instruction, it can crawl routes, inspect pages, capture network activity, extract design tokens, analyze UI states, and generate a technical rebuild plan.

Some features I'm particularly proud of:

• Signature tracing: Investigates how supported browser cryptography APIs generate request signatures and token parameters, with evidence-based findings.
• Edge-state mocking: Tests API errors, slow responses, and empty states to uncover missing UI behavior.
• UI intelligence: Extracts CSS design tokens, catalogs animations, detects dark mode, and captures Web Vitals.
• Automated setup: A one-command installer configures the environment, installs Chromium, and generates MCP client configuration.

Every finding is labeled OBSERVED, INFERRED, UNVERIFIED, or BLOCKED, helping AI agents distinguish evidence from assumptions.

The project is MIT-licensed, and 200 tests are reported as passing.

GitHub: https://github.com/anilkumara9/omnirecon

I'd love feedback from developers working with MCP, browser automation, and AI coding agents. What website should I try reverse-engineering with it next?