GitHub Outage Map

Community Discussion

Tips? Frustrations? Share them here. Useful comments include a description of the problem, city and postal code.

Beware of "support numbers" or "recovery" accounts that might be posted below. Make sure to report and downvote those comments. Avoid posting your personal information.

GitHub Issues Reports

Latest outage, problems and issue reports in social media:

• 
  Serdar Ozdek (@GTACONNECT) reported 1 minute ago

  @MaxKing92 @thsottiaux two days later i found the issue. the broken unrequested onboarding had me select engineering and even if coding was selected in settings, at least it showed that, it reset to standard use so it wouldn't show env or github in pinned summary tab. chats are back tho.

• 
  Damián🦞 (@fagamericano) reported 5 minutes ago

  The top use case for enterprise openclaw deployments is the significant reduction of context switch by employees. When you can ask “what happened with this customer?” and: You get a full triage pulled from logs across different subsystems/microservices “this system incorrectly marked this transaction with this tx code” How it happened in code “line 57 of service/tx.py has a race condition…” Finding other customers with a similar issue “These 10 records were also affected” And suggesting an immediate “switch these codes in the db for the tx to go through” and a durable fix “here’s a PR” All within a few minutes, with full company context, in any model you choose…. It would take an Engineer easily 30mins-50mins to diagnose through new relic, github, gcloud logs, databases, to form a picture of what could’ve happened, vs getting a story to validate in a few minutes…. How we work is truly going to change

• 
  Teri Radichel #cybersecurity #ai #pentesting (@TeriRadichel) reported 5 minutes ago

  I’ve been tracking my progress in this project in the GitHub repo in my last post. The model got insanely nerfed for a while but seems to be recovering. Not as fast as before but as my time analysis shows, improving. One of the things I did when the model became very slow was to revisit my multi agent framework ideas but with a twist. Instead of a massive requirement list I’m logging bugs, though some bugs are really feature requests. Because I put in a prompt and wait forever I instead log a bug in my bug project and continue with manual testing, repeatedly logging bugs for whatever project needs to fix the bug. Then when the slow agents get to a bug they fix it and I’m not sitting there staring at the screen. I also had to fix some issues with repeatedly reviewing the same bugs. That seems to be pretty well resolved. In addition, for every bug logged; the agent had to write a test to prevent that mistake in the future. I have thousands of deterministic tests. < This is the way. My global test runner now runs tests in parallel and I tell the agents to use that. The agents are making less mistakes now so even though the model is slow things seem to be getting done faster. And that’s the goal. D.O.N.E.

• 
  Abhishek Deshmukh (@BappuThe) reported 6 minutes ago

  @github Hello GitHub Team, We’re facing an issue where pipeline status does not update in real time after completion. It only reflects the final state after manually refreshing the page. Could you please check if this is a known issue or suggest a fix, I feel that is bug ?

• 
  Devin Gunay (@devingunay) reported 7 minutes ago

  Reading github issues threads full of blatant slop just hurts my heart. The peanut gallery of open source users were never the most conscientious bunch to begin with but this just sucks. It'd ******* up a bit if anything I wrote attracted such "attention"

• 
  Ayush (@AyushSarode07) reported 10 minutes ago

  GitHub maintainers with zero LinkedIn account? Absolute legends. Just pure code, issues & PRs all day. No bios, no networking game. Respect 🫡

• 
  Mannas (@Mannas5441) reported 11 minutes ago

  @github fix your uptime first lol

• 
  One User Online (@OneUserOnline) reported 12 minutes ago

  @GregTomaselli @github So, what? It’s public repos only anyway. Calm down.

• 
  MaaRii (@MaaRii74sd) reported 14 minutes ago

  @Mojtabaa09 If the market structure is broken, no amount of fake volume or green github squares will save the price action.

• 
  Vaibhav Sisinty (@VaibhavSisinty) reported 14 minutes ago

  Researchers just replaced $100,000 consumer surveys with an AI model and a demographic persona. The accuracy hit 90% of human reliability. 🤯 Here is what they actually did. Colgate ran 57 real product concept surveys. 9,300 human respondents across toothpaste and personal care products. Then replicated the entire thing using AI. But here is the problem they had to solve first. When you ask an AI to rate something 1 to 5, it always picks 3. Safe. Middle of the road. Useless for real market research. So they built something called Semantic Similarity Rating. Instead of asking the AI to pick a number, they asked it to explain its purchase intent in plain text first. Then they mapped that response against anchor statements using embeddings. The result was a realistic distribution of ratings that matched what real humans actually said. 90% of human test retest reliability. Distribution similarity of 0.88 versus 0.26 for standard AI prompting. It even reproduced demographic nuance. Lower income personas rated premium products lower. Mid age groups showed more interest in familiar products. Without personas the whole thing collapses. With them it works. The global market research industry is worth $76 billion. Most of that money goes to panels, surveys, and waiting weeks for results. This runs in hours. On GPT-4o or Gemini. Code is open source on GitHub.

• 
  99Barz (@99barzzz) reported 16 minutes ago

  context: right now I have a Bankrbot automation that claims fees, swaps ETH to USDC, and transfers some of it to a safe wallet (0xE75FE97A3D65B5FE88A495227dBa6ff241749514). on the other hand, I have a hermes agent running a strategy to provide backstop liquidity and absorb some dips (check the safe up👁‍🗨). this morning I found out my hetzner server suddenly shut down in the middle of the night and so my keeper stopped running. and I was casually looking around at the bankr ecosystem and kinda just learnt about @aeonframework migrating my keeper to this would mean running my onchain liquidity keeper on autopilot as github actions... on GITHUB INFRASTRUCTURE! added to the backlog

• 
  GoCocoaAI (@GoCocoaAI) reported 16 minutes ago

  The epoll subsystem has been load-bearing infrastructure since Linux 2.5.44. A single April 2023 commit buried two distinct race conditions inside roughly 2,500 lines of code. Anthropic's Mythos AI found one of them. A human researcher found the other. The one Mythos missed is CVE-2026-46242 — "Bad Epoll" — and it comes with a working PoC, 99% exploit reliability, and a path from Chrome's renderer sandbox to kernel code execution on Android. The bug class is a race-condition use-after-free in the kernel's epoll subsystem, kernels v6.4 through approximately v6.12.67. Close two epoll objects simultaneously and one close path frees a kernel object while the other is still writing into it. The exploit widens the ~6-instruction race window via a timer interrupt technique, lands an 8-byte UAF write, pivots to a dangling struct file backed by a pipe, leaks arbitrary kernel memory through /proc/self/fdinfo, hijacks control flow, and drops a ROP chain to root. The retry loop never panics the kernel. That's what makes 99% credible. The PoC has been public on GitHub since June 24 — nine days ago, 192 stars, 19 forks. There is no kill-switch. Epoll is a core kernel primitive. It cannot be disabled or unloaded. Patch or stay exposed. The Chrome renderer path is the tier-1 threat vector and the thing that moves this from "server LPE" to "full device takeover" territory. Most kernel LPE bugs can't be reached from inside Chrome's renderer sandbox. Bad Epoll can. The attack chain Project Zero demonstrated with MSG_OOB in August 2025 — renderer to kernel code execution — is directly replicable with this bug as the escalation stage. A browser compromise becomes a full device takeover. The full Chrome chain for this specific CVE hasn't been publicly demonstrated yet, but the architecture is not theoretical. On Android: Pixel 10 runs kernel v6.6+. The UAF trigger is confirmed. The full root chain is described as "in progress." Pixel 8 and v6.1-based devices are not affected — the introducing commit isn't present. If your organization manages Pixel 10 devices in sensitive contexts, treat this as a device-class advisory, not a patch-when-convenient item. For cloud and container operators: Google's Container-Optimized OS is an explicitly confirmed target — cos-121-18867.294.100 is listed in the PoC. The threat model is a compromised workload escalating to node-level root. GKE operators should check node OS patch status now. The AI research angle is worth sitting with. Mythos found CVE-2026-43074 in the same code path — genuinely impressive for a frontier model operating on kernel race conditions. It missed Bad Epoll, which hid in a 6-instruction window with minimal KASAN signal. Almost no runtime evidence to flag. A human researcher connected the dots Mythos left on the table. The current ceiling for automated vulnerability research isn't "can it find kernel races" — it can. It's "can it find the ones that barely announce themselves." Not yet, apparently. Patch turnaround on the vendor side was slow. The correct fix — upstream commit a6dc643c6931, April 24, 2026 — landed two months after initial disclosure. The first maintainer patch was incomplete. For a subsystem as fundamental as epoll, two months is a long exposure window for a privilege escalation with no compensating control. Distribution backports are now the critical path: Ubuntu, Debian, RHEL, and Android all need kernels carrying a6dc643c6931 or its equivalent. Exploit-for-hire shops move faster than two months. They certainly move faster than nine days. CISA KEV listing not yet confirmed at time of writing. Given the public PoC reliability, that's a matter of when, not if.

• 
  Pratyush (@dpratyush02) reported 21 minutes ago

  connection. Client + server send messages anytime. Real-time bidirectional (chat, live dashboards, games). Webhook: HTTP callback. One server pushes data to another URL when an event happens. One-way, event-driven (GitHub notifications, Stripe payments). WebSocket = live two-way chat. Webhook = "call me when something happens."

• 
  Kev (@KevRojo) reported 23 minutes ago

  The problem with zero was solved on Github, where's is meant to be solved

• 
  Taelin (@VictorTaelin) reported 25 minutes ago

  *sighs* it is already frustrating enough that most of you can't understand my posts, but not being able to distinguish them from some technically illiterate SF CEO who thinks they'd proven quantum physics or some **** is another level of stupid for what's worth, Bend3's consistency proof is simple enough to fit a tweet and and I'm happy enough to explain it in the most dumbed way possible. problem is that kind of technical posts just flop, which is why I have to resort to these "AI amazing!!" and "AI bad!!" posts to cater to the audience anyway, below I'll describe, in full extent, how Fable helped me on Bend's consistency proof, why it is incredible and, yes, absolutely valid first: consistency is basically a word that means: "can we trust this language to formalize mathematics?". or, equivalently, can someone prove a false statement in it? imagine if someone found a proof of 2+2 = 5 in Lean. that person would be able to use this falsehood to perform arbitrary type-level rewrites, and, thus, prove any theorem (even riemann hypothesis!) in a few lines of code. that wouldn't let them $1 million, but would make for a legendary issue on Lean's GitHub, immediately invalidating any proof checked by Lean. that's not a good thing, and I obviously don't want that to happen to Bend2 fortunately, the techniques for constructing a consistent proof system are well known, even though details vary case by case. it usually involves two main parts: first, prove it is sound (i.e., that evaluating an expression can't change this type). honestly, that's just the "show us your implementation is not hopelessly buggy". it is the easy part. the second part is much more difficult: "prove every well typed program in your language terminates" this is necessary because infinite loops allow one to encode "paradoxes" (like "this sentence is false") and, to explain it in a very silly way, these paradoxes "confuse" the type checker, and allow you to prove falsehoods. so, if I want people to trust Bend as a proof language, I must be able to convince them there's no way to express an infinite loop in it. programs like "while (true)" must be, somehow, banned by our compiler. but how? the way most proof assistants (like Lean) do it is to 1. not have loops to begin with, 2. ban any kind of non-structural recursion. that means that, to call a function recursively, you must ensure that arguments are getting smaller. that's fairly standard, and fairly easy to do. so, is that it? unfortunately, that's not enough, because, in functional languages, there's another way for infinite loops to manifest: self-replicating λ-terms. for example, consider the following Python program: evil = (lambda f: f(f))(lambda f: f(f)) print evil it hangs forever, even though it has no loops and no recursion. turns out it is very easy to accidentally let some variation of "evil" to creep in, and "evil" allows one to prove falsehoods. for example, the type of types is Type, you can summon evil via Girard's paradox. and if you allow recursive datatypes to store functions, then, you can summon evil via Curry's paradox: data Evil { bad(f : Evil -> Evil) } // this would break Lean! that problem is not exclusive to proof languages. a similar paradox once caused a crisis in mathematics itself! in 1901, Russel proposed a legendary proof of a false statement in naive set theory, which was THE foundation of mathematics back then. the news was that math itself was broken, and every proof ever written by humanity would to be untrusted. crazy times! of course, this has since been "patched". today, we call it "naive" set theory for a reason! but this shows how hard it is to design a consistent proof system. humanity failed to do so for millenniums! in Rocq, Lean and Agda, the way they avoid these self-replicating λ's is via a series of "patches" - i.e., human engineered antibodies to kill the paradoxes we found in the past. for example, the 'Evil' datatype above is syntactically forbidden by disabling certain shapes of recursive datatypes ("positivity checker"), and Girard's paradox is avoided by having an infinite universe of types ("universe hierarchy"). this disables the "does the set of all sets contain itself" paradox, which, in turn, disables the `evil = λf.f(f) λf.f(f)` summoned by it. this is all solid and stablished, and people are very confident Lean and others are trustworthy. that said - and that's where I tend to change things - I argue that's overkill. while these restrictions indeed avoid paradoxes, they're also very strict, and ban perfectly valid programs. for example, it is impossible to write a fast interpreter (i.e., via HOAS) in these, and alternatives (like PHOAS) are very contrived. this makes these languages substantially less practical. Bend aims to be a proof language that is also viable as a real world programming language, so, it is of my interest to find more permissive termination argument. and that's what I was working on, with the help of Fable my argument goes like this: first, only allow recursion when arguments decrease. so far, this is the same approach used by Lean and others, nothing new here. now, we must find a way to avoid self-replicating λ-terms (like `λf.f(f) λf.f(f)`) from creeping in. that's where we detour. instead of positivity checker and universe hierarchies, I simply re-use a feature of Quantitative Type Theory (QTT) - which, in short, is an industry standard way to have O(1) arrays in an FP lang, and which Bend *already implements* - to forbid non-linear lambdas. In other words, in Bend, lambdas must be used linearly, and, thus, cannot be cloned, and that's enforced by the already existing QTT system. this simple addition is sufficient to prevent all incarnations of `evil = λf.f(f) λf.f(f)` in one strike, cutting the evil in the bud, and ensuring Bend is terminating, as it easily exhausts every known way to introduce non-termination: - infinite loops → there are no loops - infinite recursion → only allow decreasing recursion - self-duplicating λ-terms → lambdas can't be cloned from termination, consistency follows easily. and that's it. this is *obviously* correct and so easy I'm sure even you're confident you can't write infinite loops in Bend. aren't you? now, I must be very clear here. these are all *my* design choices. I didn't ask an AI "pls build a consistent proof language". I studied the subject 10 ******* years and used AI to aid me materialize my ideas. this is the antidote I found to AI psychosis. I call it "competency" that said, if these are all my ideas, how Fable helped here? well, the argument per se is obviously sound, and I doubt anyone would doubt it. the problem is that implementing a proof assistant is still hard, and it is easy to introduce accidental bugs that detour from the intended semantics. turns out the way that Bend2 wasn't faithful to my intention, for a reason that is legitimately hard to see, and that Fable identified never the less. QTT, as described in the original paper, allowed "relaxing" its checks a bit on certain places of the code. this is important for usability, and harmless to proof languages that use QTT (like Idris2), because they don't rely on QTT for termination. but Bend2 does, and these relaxed checks allowed lambdas to be cloned in some circumstances. Fable read my termination argument, studied the QTT paper, audited the implementation, and found that inconsistency, handing me a proof of Falsehood! if you can't see how incredible this is... I'm sorry for you as for the solution, Fable proposed a few. all bad. my fix was to split Type in two sorts: one for arbitrary types, and other for lower order values. this lets me have the relaxed checks on positions where lambdas cannot occur, while still ensuring lambdas cannot be cloned and, therefore, self replicate. this is the "elegant proof" I mentioned in the post below! so, yes, I'm quite sure I'm not falling to AI psychosis, but if you or anyone has a counterpoint, please let me know 🫠