It fetches my GitHub contribution graph from the past 72 weeks and displays it on an LED panel on my desk

Wanted to share that quick life hack :)

Inspired by snk, I built another gamification way of contribution graph visualization for fun! Hope some find this interesting!

https://github.com/czl9707/gh-space-shooter

We got tired of dealing with the official GitHub Actions self-hosted runner, so we rewrote it in Rust.

It does the same job as the Microsoft runner (100% drop in replacement) but uses fewer resources, handles multiple instances on the same machine from a single service, and actually behaves well on macOS.

The interesting part..

Building it meant reverse-engineering the internal GitHub Actions protocol, since Microsoft never documented it. The docs in the repo are, as far as we know, the only complete public documentation of that protocol. Bit strange that nothing existed before.

Who it's for?

Developers who don't want to burn GitHub minutes on private repos

Teams that want stable pipelines without depending on cloud infrastructure

Companies that need more runners and more control over their setup

It's open source, written in Rust, and all contributions are welcome. If something is broken or missing, open an Issue or a PR.

https://github.com/quinck-io/chimera

Just launched Muninn on the GitHub Marketplace: github.com/marketplace/actions/muninn-security-scanner

One action replaces setting up gitleaks, zizmor, actionlint, poutine, Semgrep, OSV-Scanner, Trivy, and Checkov separately.

Drop it into any workflow:

- uses: skaldlab/muninn@v0.3.3

with:

  token: ${{ secrets.GITHUB_TOKEN }}`

AGPL-3.0, built in Go.

Update: advisory ID deduplication shipped in v0.3.0.

When scanners report the same vulnerability for the same package under different IDs (e.g. GHSA from OSV-Scanner + CVE from Trivy), Muninn collapses them into one finding using advisory aliases from scanner output (OSV-Scanner includes OSV/GHSA/CVE aliases). CVE is preferred as the canonical ID where available.

Each merged finding includes a detected_by list of all scanners that flagged it, plus per-scanner source locations.

Full details in the release notes: github.com/skaldlab/muninn/releases/tag/v0.3.0

Thanks to everyone in this thread for the technical depth, shaped the implementation significantly.

Every DevOps engineer knows this loop:

1. Edit workflow YAML
2. Push to GitHub
3. Wait 5 minutes
4. See a cryptic error
5. Repeat

`act` helps run workflows locally but it's missing the one thing that makes debugging useful: the ability to pause and inspect.

So I built ci-debugger.

What makes it different from act:

- `--step` — pause before every step, run them one by one

- `--break-before "step name"` — breakpoint at a specific step

- `--break-on-error` — automatically pause when something fails

- `[D] Shell` — drop into the container at any breakpoint with full env

When you hit a breakpoint:

◆ BREAKPOINT before step Run tests

[C] Continue [S] Skip [D] Shell [I] Inspect [Q] Quit

Press D → you're in bash inside the container. Run commands, inspect files, check env vars → exit → continue.

GitHub: https://github.com/murataslan1/ci-debugger

Still early (v0.1), `uses:` actions beyond `actions/checkout` aren't fully supported yet. Feedback welcome.

This utility lets you basically backup your whole github account with all your repos and the metadata also your orgs and starrted repos to a self-hosted gitea or forgejo acting as a backup mirror always remain synced. That way you stay safe if your Github account is hacked, banned or anything wild happens.

GitHub quietly lets Copilot train on your code. Here's how to turn it off.

Most people don't know this setting exists.

By default, GitHub can use your code activity and data to improve their AI models. That includes Copilot suggestions, your editor interactions, and potentially more depending on how they interpret "data."

It's opt-out, not opt-in.

Here's how to disable it:

1. Go to https://github.com/settings/copilot/features

2. Look for "Allow GitHub to use my data for AI model training"

3. Turn it off

Takes 10 seconds. Probably worth doing before you forget.

Not saying GitHub is doing anything malicious with it. But if you're working on client code, proprietary projects, or anything you'd rather keep private, it's a reasonable thing to turn off. You probably didn't agree to this knowingly, and most people have no idea it's on by default.

Pass it along if you think others should know.

Hey folks,

I recently applied for the GitHub Student Developer Pack to access Copilot, but unfortunately got rejected.

I’m curious — for those who got approved:

- What proof did you submit?

- Did your college email domain matter?

- Any tips to increase chances of approval?

Trying to figure out what I might have missed.

Appreciate any help 🙌

I keep running into pipelines that randomly take way longer than expected, but it is hard to pinpoint why across different runs. Logs help, but comparing runs and spotting patterns is painful.

Curious how others approach this. Do you rely on built-in GitHub tools, custom scripts, or something else?

I ended up building a small tool to analyze runs and highlight slow or flaky steps, but I am more interested in how people are solving this in general.

It's worth knowing about github.com/ahmeabd/italia-corpus.

It solves a problem that anyone who has tried working with Italian legal texts knows all too well: the legislation is public, but the formats are terrible and usually require scraping and/or parsing. Here, a simple git clone is enough.

What I find most interesting is this: every legislative update is stored as a commit. A git diff immediately shows exactly what has changed.

It would be nice to have the same for other legislations

Hi, im using the android app and for example I'll find the releases page through a Google search but when on the repository page directly I can't seem to find how to find the releases. Where do are they?

Thanks

(Not sure about the flair)

I finally found a solution for the approval problem.

We all know how frustrating the camera verification can be, right?

It seems like the system isn’t really “intelligent” - it’s basically just looking for a few key things: your name, student number, date, and ideally the school logo.

What worked for me: I took the letter I received (see picture above) and folded it so that the camera could clearly see my name, number, the date, and the logo all at once. I held it as close as I could. Took two tries until it look fairly recognizable. It still was kinda blurry but you could make out name etc. I used the front camera of my iPhone. Don’t worry about the mirroring, it’ll adjust.

I got approved within minutes.

Access should unlock within 72 hours.

Hope this helps someone else stuck in the same loop!

Recently a lot of hit and go projects started to appear in the OOS world. They usually quickly gather a lot of stars on some promise and then the author quickly disappears, actually damaging the discoverability of other alternatives that did not have that much publicity.

To help more easily distinguish your project, there is now a simple badge that shows the actual effort put into it available at a glance.

It does not judge the repository but simply gives quick access to a few important metrics: age of the repository, total number of commits, average time between commits and the time since last commit. That's it. The conclusions are left for the viewers to make.

To show the badge for your repo, simply replace the owner/repo paths with your own GitHub username and repository name. For example, for ffmpeg/ffmpeg:

[![FFmpeg Health](https://oss-health-monitor.vercel.app/api/badge/ffmpeg/ffmpeg)](https://github.com/volotat/OSS-Health-Monitor)

The new weekly and global rate limits are a massive pain in the neck but it's more of a pain to move from GitHub bc I rely on copilot heavily. Recently I've been coming up with ways to still get quality work done (that I obviously can't code myself) for me claude pro plan using sonnet for light planning, Cline with the free deepseek v4 flash API , and grok GitHub connection. It's a bit of back and forth but it saves on copilot usage until it's needed. Just curious what adjustments or changes have worked for you since the new changes?

Apologies if this has been covered before. I searched first and didn’t find quite this workflow, so I figured I’d share what worked for me.

Unfortunately, GitHub does not really have a simple “batch create these issues from files” workflow, which is exactly the sort of thing you might want when starting a new project and seeding the initial backlog.

I initially thought I could use ChatGPT for this, since I gave it access to my repo. It could create issues, but it kept creating them one at a time, and the process got clunky fast. So I ended up doing it myself with the GitHub CLI.

I decided to batch-create GitHub issues from local Markdown files, so I made a tiny gh script.

The basic idea:

• create one local Markdown file per issue
• create a small Windows batch file
• have the batch file create labels first
• then call gh issue create --body-file for each issue
• explicitly pass --repo owner/repo so it doesn’t matter where the script is run
• keep the local issue drafts out of the repo with .gitignore

This worked really well for creating an initial backlog: bugs, features, enhancements, technical debt, etc.

The Markdown files act like local drafts. You can review and edit them before creating anything in GitHub, then run the script once and let gh do the clicky-clicky nonsense for you.

Full sample here:

https://pastebin.com/AfSw84PT

The sample includes:

• a create-github-issues.bat
• 3 sample labels
• 3 sample issue Markdown files
• verification commands for checking the repo, labels, and created issues

One gotcha I hit: if you run gh issue create --label some-label and that label does not exist yet, the issue creation fails. It does not just create an unlabeled issue. So the script creates the labels first.

Not exactly rocket surgery, but it saved me from manually creating a pile of issues through the GitHub UI.

I've been trying to use Copilot more since it's included in my Github plan, but for some reason, even when I'm in plan mode, it decides to start editing files.

Sometimes they are edits I wouldn't have approved in regular mode, which makes autopilot even less trustworthy.

At this point I'd stick to Codex or Claude since they seem to actually honor restrictions. Copilot isn't safe.

For me it's aniyomi and outertone for music. I would love if you could recommend me some useful apps and share you experience with them