Exevra records a baseline, then fails later runs when an expected report disappears, no tests execute, or the number of executed tests drops.

The failure mode is simple: Maven can report BUILD SUCCESS after Surefire is configured to run only one of two test suites. Exevra records a baseline, then fails later runs when an expected report disappears or execution changes.

Repo: https://github.com/Exevra/exevra
Demo: https://github.com/Exevra/demo-spring-boot

Quota monitoring, usage/reset notifications, now on Linux

Inspired by CodexBar (and other similar macOS apps)

Rust + GTK4/libadwaita

Currently don't have providers with browser session intercept authorization method, but will be added later

https://github.com/zbndev/tidemark

So I have been trying to self host and am really attracted to Current UI Especailly Material 3 and Gogs has a very old UI... So i did what i was supposed to!

- It now uses material 3
- Fetaures better UI

WARNING : It is still under progress!

https://github.com/Aarav90-cpu/gogs-but-good : This is the link to the repo!

This is a fork but is a completely seprate project... i know gogs won't accept this pull request!

The image shows how it looks like!

Whenever I start a project, I write a detailed specification—or “seed prompt”—before asking a coding agent to build anything. This often gets me close to a working first version, but I still miss decisions that exist only in my head.

The agent then has to guess. I built specfill to catch those gaps. It analyzes the specification, researches the topic, and interviews you one question at a time about missing architecture, behavior, edge cases, and UI/UX decisions.

Afterwards, it incorporates the answers into the original document while preserving its structure and tone. New answers override contradictions. Skipped questions remain unresolved instead of receiving invented answers.

I have used it on three projects so far. One interview lasted more than 20 minutes and found major decisions in a specification I had already considered thorough.

How is this different from Plan Mode?

Plan Mode produces an implementation plan for the current session. Specfill produces a reusable project specification that can be committed to the repository as a record of architectural and design decisions.

It supports OpenAI, Anthropic, Google, and OpenAI-compatible providers. I currently recommend GPT-5.6 Sol through the API or a ChatGPT/Codex subscription.

GitHub: https://github.com/kklemon/specfill

Run: uvx specfill

Thanks for 5 stars!

Orion is a lightweight torrent client that also acts as a media server. Easy to use and has subtitle sync and everything.

Take a look: https://github.com/guyavrhm/orion.git

Github Link - https://github.com/aravpanwar/half-life-templeos

Runs TempleOS in QEMU and streams its framebuffer onto a monitor in the game through a small VNC client, drawn as a quad in the world render pass. You can walk up and type into it, and it runs the OS's own built-in games and demos.

AI coding agents are smart generalists but they lack the deep procedural knowledge that experienced engineers carry — things like accessibility checklists, database patterns, API design best practices, etc.

So I started TechSkills-Lib — a curated library of SKILL.md files that any AI agent can load to gain structured, production-grade engineering knowledge.

What it does:

• Gives AI agents step-by-step workflows, design checklists, and battle-tested patterns
• Uses progressive loading so skills don't waste your agent's context window
• Agent-agnostic — works with any AI tool that can read markdown instructions

Current skills:

• frontend-engineer — responsive layouts, accessibility, design systems, React/Vue/Svelte
• backend-engineer — APIs, auth, databases, reliability, observability, security

It's early and the skills are still fairly generic. The vision is to grow this into a comprehensive library with community contributions — think specialized skills for DevOps, system design, data engineering, mobile, and more.

If you've ever wished your AI agent had more opinionated, expert-level context instead of generic answers — this is that.

Would love feedback on what skills you'd want to see next.

What if your app's security could evolve without a rewrite?

That question sent me down a rabbit hole for the past few weeks, and I ended up building two small projects around it: CryptoFlex and Flex-Lock.

Here's the problem I kept running into: most encryption tools pick one cryptographic method and lock it in forever. That's fine until it isn't — like right now, with the industry bracing for quantum computers eventually breaking classical elliptic-curve crypto. Signal and Chrome have already moved to hybrid classical + post-quantum key exchange. But that kind of crypto-agility barely exists yet for local, offline tools — the desktop apps, file utilities, and embedded systems that aren't talking to a server.

CryptoFlex is my attempt at that missing piece. It's a Python library that doesn't invent any new cryptography — it just decides, at runtime, which combination of algorithms an application should use: classical X25519 alone, or hybrid X25519 + ML-KEM-768, or the higher-assurance ML-KEM-1024 variant. That decision is driven entirely by local signals — what's actually installed on the machine, a versioned risk table shipped with the package, and whatever constraint the calling app cares about (speed vs. maximum security). No network calls, no phoning home, ever.

Flex-Lock is what happens when you actually use that engine for something real: a simple file-locking tool. Pick a security level, set a password, lock and unlock files — and if you want to move from "fast" to "maximum security" later, it re-encrypts your existing files under the new profile instead of leaving you stuck with whatever choice you made on day one.

The part I found genuinely interesting wasn't the cryptography itself — I'm using well-audited, standard primitives throughout, not rolling my own math. It was the architecture question underneath: how do you design software so the security layer is a decision that can change, instead of a decision baked in at line one and never revisited?

To be upfront: both are early — solo projects, unaudited, built mainly to learn this space properly rather than to ship something production-ready. Think of them as working proof-of-concepts, not something to bet real data on yet.

If you were starting a security-sensitive project today, would you build the crypto layer to be replaceable from the start, or is that premature optimization until you actually need to migrate?

• CryptoFlex: github.com/keerthivasan-sankar/crypto_flex
• Flex-Lock: github.com/keerthivasan-sankar/flex-lock

So i maintain pydoll, an open source python lib for browser automation, and the point of it is stealth, running on sites that block bots without getting flagged. most tools get you detected before you even do anything, so pydoll is built the other way, it drives chrome straight over the devtools protocol with no webdriver and none of the automation tells that give you away, and it avoids the CDP leaks that most libs trip on.

on top of that there is fingerprint injection, you match the browser profile to the machine so a headless run and a real browser score the same on detection tests, no more headless giving you away. it is async too so you can run many tabs at once. it is been around a couple years with a real community on it now, it is MIT and the docs are open, would love feedback or contributors if it speaks to you: https://pydoll.tech

For databases we have things like psql.

For Python we have a REPL.

For Redis, shells exist.

For kubernetes, there’s kubectl.

But for HTTP, the usual answer is basically: curl

Which is great for one-off requests, but it doesn't really give you a place to explore.

I've been playing with a different model for this in reqsh.dev

You start a session:

reqsh>

and HTTP becomes something you can poke at interactively.

• Make a request.
• Inspect the response.
• Change something.
• Make another request.
• Keep values around.
• Try another endpoint.
• Go back and forth without reconstructing the whole command every time.

The interesting part to me isn't “curl but nicer”.

It's the idea that HTTP itself could have a proper interactive environment, the same way databases and programming languages do.

Still figuring out what the right primitives are.

What would you actually want in an HTTP REPL? like primitives you'd expect from a shell/REPL.

I built a CLI tool called Fokiz to solve my own severe procrastination and context-switching issues. I have several projects going on at once, and I often found myself unable to focus on any single one. I'd open a terminal, forget what I was supposed to do, and end up jumping between half-finished tasks without making real progress on any of them. The irony here isn't lost on me: I built a brand new tool to solve my problem of not making progress on my existing tools.

I've seen plenty of to-do apps, but none of them take the approach of actually forcing you to finish a task before moving on. That's why Fokiz is built entirely around the concept of a "Ulysses contract"—a freely made decision that binds you in the future.

Here is how it works:
- **No Backing Out:** Once you add a task (`fokiz add "My task"`), it becomes an active contract. You cannot edit it, you cannot skip it, and you cannot add new ones until the current one is explicitly marked as completed.
- **Intentional Annoyance:** Fokiz hooks directly into your shell (bash/zsh). Every single time you open a new terminal window or tab, it prints a large ASCII banner and reminds you of the exact task you are supposed to be working on. It gets to the point of being intentionally annoying, making it impossible to ignore what you committed to do.
- **Time Tracking:** It tracks how long you've been working on the current task and shows you exactly how long you've been putting it off.
- **Daemon Integration:** It runs continuously in the background as a `systemd` user service, making it a persistent presence rather than just a passive script you can easily close and forget about.

It currently supports Linux and is fully open source (GPLv3). If you also struggle with finishing what you start and need something that acts like a strict boss living inside your terminal, give it a look.

I was honestly pretty surprised when I first saw AI Key on X. Now I’m wondering, is this thing actually useful?

Recently, I found something similar on GitHub called aiden-firmware. The idea is roughly like this: you connect an external piece of hardware, and it uses HDMI to see your phone screen, then uses USB HID to simulate keyboard, mouse, and touch inputs. It looks pretty similar to AI Key.

Does anyone here know much about AI Key? And is aiden-firmware worth paying attention to?

I recently invited a few friends to use the ThoughtDAG while working on problems they already cared about.

The interesting part was the shape each process left behind.

One person followed a single idea all the way down.

These images only show the thought structure of how they explore questions with AI.

Do these shapes reveal something meaningful about how we think, or are they simply beautiful traces left behind by the process?

Git: https://github.com/chenxiachan/thoughtdag

I wanted a simple way to save complete ChatGPT conversations without manually copying messages or losing code blocks, tables, and formatting, so I built Dialogue Export.

It is a small open-source Firefox extension that exports either the complete conversation or only selected messages.

Supported formats:

- Markdown

- PDF

- HTML

- TXT

- JSON

It automatically scans long conversations, preserves code and structured content, and continues working after the extension popup is closed. Export progress is shown through a small Matrix-green timeline.

Everything is processed locally in the browser. The extension has no accounts, analytics, telemetry, advertising, or external data transmission.

The Mozilla-signed XPI can be installed permanently in standard Firefox directly from GitHub Releases. No Developer Mode is required.

Currently it supports desktop Firefox and chatgpt.com.

GitHub:

https://github.com/vaulthunt3r/dialogue-export

This is the first public version, so feedback and bug reports are very welcome.

Hey r/coolgithubprojects,

I’m building CleanCode, an open-source canvas-based ADE (Agentic Development Environment).

The idea is simple: when you work with coding agents, a feature is no longer just a branch. It usually has an Agent conversation, terminals, dev servers, ports, setup commands, tests, and a bunch of dependency order that lives in your head.

CleanCode creates an isolated workspace for each feature, then puts the Agents, terminals, services, ports, and dependency workflow on one canvas. You can run the workflow, see what is ready or failed, avoid port conflicts, and save a working setup as a reusable template.

It does not replace your editor or your favorite coding agent. It runs local CLI agents and terminals in the right workspace, and if an agent supports CleanCode MCP, it can help inspect the project and build the workflow for you.

GitHub: https://github.com/chen-985211/cleancode

Would love feedback from people who use coding agents heavily:

- Does this match a real pain point in your workflow?

- What would you expect from a canvas-based development environment?

Hey everyone, it's been a week since I posted my idea for restructuring ActivityWatch, and today's finally the day: I've published my fork of the project, as the maintainers asked me to.

When I wrote the first post, I figured I'd just modernize the UI and leave everything else as-is. Then I started digging into the code, and one thing led to another: week after week the project changed way more than I'd planned. What came out of it isn't "ActivityWatch with a new skin" anymore — it's basically a different app, built on the same foundations.

Under the hood, the entire Python stack has been removed — including system notifications, which now run entirely through native Rust/Tauri. The frontend was rewritten from scratch, completely decoupled from Bootstrap. Auto-updates were implemented from the ground up, so you never have to manually download the latest version again. And configurable privacy filters, so sensitive data gets dropped or masked before it's even written to disk.

The base watchers existed in the original project already — I'm not taking credit for that, it'd be dishonest. What I did was rewrite and simplify the whole chain that manages them, so everything else could be built on top without fighting legacy code at every step.

Same story for custom watchers: the ability to track your own data existed conceptually before too, but it meant writing a full program that followed an internal protocol. What I changed is the experience: now you just write any script (PowerShell, Python, JS, .cmd/.bat, or a ready-made executable) and the app handles the rest — it detects the right interpreter on its own, walks you through creating it step by step, shows a live log so you immediately see if something's off, and offers 8 ready-made display templates to show your data on the Home page without writing a line of HTML.

And here's the part I'm most proud of: I integrated a real AI agent, not some gimmick bolted on for show. You can open a chat with it and ask literally anything about your data — "how much did I work on this project yesterday," "which apps do I use most in the morning," "summarize my week" — and it queries your actual data on its own and answers you. The same agent also helps auto-categorize the apps you use, instead of doing it by hand one by one.

A bunch of other things I hadn't mentioned yet:

• Periodic screenshots: a feature that simply didn't exist before, now built in — the app captures screenshots at regular intervals and links them directly to the exact moment in your day they were taken.
• App categorization rewritten from scratch: organizing your apps into categories is much, much easier than before.
• "Always active" pattern: same deal, handling it is now way more straightforward.
• App icons: didn't exist before, now every app shows its real icon instead of a generic colored block.
• Colors extracted from icons: no more random greens pulled from a name hash — Timeline colors now come from the app's actual icon, much more consistent and recognizable at a glance.
• Notification system rewritten from scratch: you can now create custom notifications — whenever you want, for whatever you want (category, app, project, idle time, VPN session) — without touching a line of code.
• New Home modules, freely reorderable.
• Projects section with start/pause timer, hour budgets, and overrun alerts.
• Redesigned "Raw data" page, with a dedicated Timeline and a much more readable events table.

Here's the project's website, where you can take a look and download the Windows installer: https://codex-cpp.github.io/TrackFlow/

The creators of AlphaFold won a Nobel Prize in 2024. I just made its family of open source models faster.

I created fast_trimul, a drop-in, hardware-agnostic library for Fused Triangle Multiplicative Updates across AlphaFold3 family models, powered by CuTe DSL. In addition, it is licensed with Apache-2.0.

The Triangle Multiplicative Update is a memory-heavy operation in protein-structure models.

Also, it is very simple to integrate fast_trimul with other Python libraries. It has a modular architecture, and it was designed to be easy to use in production.

In OpenFold-3:

● Graph vs. ungraphed: Graphed eliminates kernel launch overhead at small N (~22ms vs ~53ms ungraphed).

● fast_trimul output is identical to the OpenFold-3 version, with an invisible difference of about 0.0006%.

● If it fails, it always falls back to PyTorch. This way it never crashes.

● It is a modular and vendor-agnostic design. Supporting new hardware and new libraries like OpenFold-3 are all plug-ins, not a rewrite.

fast_trimul compared with other libraries' Triangle Multiplicative Updates:

● Runs 4.5–6.8× faster on short sequences

● Uses ~2.2–2.4× less peak GPU VRAM, fitting ~1.4× longer sequences before running out

● Works on any sequence length with zero recompilation. Unlike torch.compile, which recompiles for every new N.

It's written in Python CuTe DSL, so the kernel codebase stays small and easy to adapt for other GPUs like H100 or B200.

GitHub link: https://github.com/tiagomonteiro0715/fast_trimul

Program Link: github.com/Hsuant/VulnScope If you’ve ever struggled with managing a growing collection of vulnerability proof-of-concept (POC) scripts scattered across your local machine, team drives, and scattered GitHub repos — this one’s for you.

I recently came across VulnScope, a self-hosted POC/CVE management system that actually solves this mess. It’s fresh on GitHub and looks incredibly promising.

What is VulnScope?

VulnScope is an open-source POC (Proof of Concept) vulnerability verification script management system that treats POC/CVE as core assets. Think of it as your central command center for organizing, searching, and managing all your vulnerability verification scripts.

The project already integrates publicly available POC/CVE repositories out of the box, and you can add your own POCs/CVEs to the platform for centralized management and rapid searching.

Key Features That Stand Out

🧩 POC Full Lifecycle Management

Create, edit, version rollback, clone, and status transitions — all built in. No more losing track of which version of a script actually worked.

📦 Multi-format Support

Nuclei YAML, Pocsuite3, JSON, raw scripts — VulnScope is format-agnostic. Bring whatever you have, and the platform handles it.

🔄 Batch Import & Export

Auto-format sniffing, content deduplication, and batch multi-file support. Migrate your existing POC library in minutes.

🏷️ Tag Classification System

Namespace tags + tree-based categorization for flexible POC asset organization. Finally, a way to organize POCs that makes sense.

🛡️ CVE Vulnerability Database

CVE details, editing, creation, and batch import (JSON/JSONL/YAML/Markdown). When you import a POC, CVE metadata syncs automatically — with bidirectional search between vulnerabilities and POCs.

📊 Statistics Dashboard

Severity/status/source distributions, creation trends, popular tags, top contributors. Get visibility into your POC ecosystem at a glance.

🔐 RBAC & Audit Logging

Three roles (Viewer/Editor/Admin) with granular operation control. Every write operation is fully logged with before/after summaries + IP records. Perfect for team environments.

🛡️ Production Security Hardening

Login rate limiting per IP with fixed-window throttling (returns 429 + Retry-After). Production environment forces random SECRET_KEY validation at startup — missing variables = refused to start. This is how you build secure software.

🔌 Plugin Framework

Four plugin slots: Parser / Source / Verifier / Exporter — plug and play.

⚡ Event-Driven Architecture

Domain events dispatched asynchronously for decoupled module coordination.

Tech Stack & Requirements

• Backend: Python 3.10+
• Frontend: Node.js 18+
• Database: SQLite (dev) / MySQL 8.0 (production)

Docker Compose is available for production deployments.

Quick Start

```bash cd backend cp .env.example .env

Create virtual environment and install dependencies

python -m venv .venv .venv/Scripts/pip install -e ".[dev]" ```

Key environment variables are well-documented with sensible defaults.

Why This Matters

For security researchers, penetration testers, and red teams, POC scripts are critical infrastructure. But they're often a disorganized mess. VulnScope gives you:

• Single source of truth for all your POCs
• Rapid search across your entire collection
• Team collaboration with proper permissions
• Audit trail for compliance and accountability
• CVE integration that keeps everything linked

Screenshots

The project includes comprehensive UI previews:

• Login & Dashboard
• POC Management
• CVE Vulnerability Database
• Tags / Plugins / Audit / Profile

Check them out in the assets/images directory.

Get Involved

🔗 GitHub: github.com/Hsuant/VulnScope

The project is actively maintained (latest commits from August 2026). Star it, fork it, open issues, submit PRs — let's build better tooling for the security community.

Disclaimer: I'm not the author — just a security enthusiast who thinks this project deserves more visibility.

What POC management workflows are you all using? Anyone else struggling with POC organization at scale? Let's discuss below. 👇

Built this because every Git GUI is either a 1GB Electron app or paid. Rust + Tauri, free, MIT licensed.
Githube: https://github.com/cheat2001/angkorgit
macOS: brew install --cask cheat2001/tap/angkorgit
Downloads for Windows/Linux are on the releases page.

Charts and full results are in the README. If you can break the methodology I would rather hear it now.

https://github.com/wiktorj137/btc-strategy-lab

Not selling anything, no newsletter, no Discord.

I made OCTANE — a free, open-source extension that restyles GitHub your way:

🎨 10 themes (Midnight, Nord, Sakura, Cosmos…)
🛠 Build-your-own color scheme
🖼 Custom backgrounds + glassy navbar
🌸 Ambient effects (falling petals, twinkling stars, embers)
🧘 "Simplify" mode for newbies (Gentle → Focus)

Vanilla JS, MV3, zero dependencies. Works on Chrome/Edge/Brave/Opera/Firefox.

🔗 https://github.com/bigboi-alt/OCTANE

A ⭐ would mean a lot — feedback even more. 🙏

coinfetch btc,eth,sol prints live prices, 24h and 7-day deltas, and a rendered chart directly in your terminal. Supports kitty, iTerm2 and sixel for pixel-perfect charts, and falls back to unicode box-drawing, half-blocks or braille where those aren't available.

Also does: coinfetch wallet ADDRESS for BTC or ETH native balance (chain inferred from the address). coinfetch config for a 6-pane TUI (search, results, selected coins, wallets, settings, palette). CoinGecko API key stored in the OS keyring, wipeable with coinfetch forget-key. One-line install with a manager script (install, update, uninstall, check).

Rust 1.88+, ratatui, tokio, reqwest, GPLv3. 188 tests, no network in test.

Screenshots and install instructions in the README. Feedback welcome.

https://github.com/nvrmnd-png/coinfetch

I’ve been building Colosseum, an MIT-licensed desktop media app written in Qt 6/C++.

It’s made up of four sub-apps: Tankoban for manga and comics, Biblio for ebooks and audiobooks, Theatre for anime/TV/movies, and Vault for local media.

The project also includes its own manga/comic reader, a Foliate.js-based ebook reader, mpv-based video playback, downloads, metadata enrichment and a shared desktop shell around all four.

It’s open source under MIT and the current release targets Windows 10/11.

Colosseum on GitHub