GitHub status: access issues and outage reports

Problems in the last 24 hours

The graph below depicts the number of GitHub reports received over the last 24 hours by time of day. When the number of reports exceeds the baseline, represented by the red line, an outage is determined.

Most Reported Problems

The following are the most recent problems reported by GitHub users through our website.

• Website Down (67%)
• Sign in (19%)
• Errors (15%)

Live Outage Map

The most recent GitHub outage reports came from the following cities:

City	Problem Type	Report Time
Créteil	Website Down	19 days ago
Trichūr	Errors	23 days ago
Brasília	Sign in	23 days ago
Lyon	Website Down	23 days ago
Tel Aviv	Website Down	27 days ago
Rive-de-Gier	Website Down	27 days ago

Full 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:

• 
  Rambone (@vinrambone) reported 6 minutes ago

  @sudoingX My blank github days are spent deep in a rabbit hole of code im not ready to push bc its too broken But i dont want to *** restore.

• 
  Polsia (@polsia) reported 11 minutes ago

  Codebase undocumented. Questions piling up. Docs rotting the moment you ship. That's every team's reality. Built DocuGuard to fix it. Monitors GitHub repos, auto-generates docs, updates wikis, flags code smells — all in real time, right in your pull requests. Live soon.

• 
  Burkino 🥇‏ (@Burkino_1) reported 17 minutes ago

  @RoombaBoomba69 @Pirat_Nation They're saying reverse engineering the game to then recreate the server and distribute it through GitHub violates their IP. 1 step further, maybe the server stores/send map chunks, so they also throw the map file up on GitHub

• 
  Pratyush (@dpratyush02) reported 19 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."

• 
  Anto Patrex (@antopatrex1) reported 20 minutes ago

  vox just let you talk to github copilot instead of typing. no cap this fixes the "staring at blank screen" problem fr fr. your hands stay on the keyboard, your brain stays in the code.

• 
  Mvykool (@mvyk0l) reported 21 minutes ago

  @satyanadella Can yall just ******* fix Windows or GitHub????

• 
  Taelin (@VictorTaelin) reported 26 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 problem is, when I write long technical posts, they tend to just flop, which is why I have to resort to these "AI good!" and "AI bad!" posts, which, I admit, may sound a bit... over-excited sometimes. that said, Bend3's consistency proof is simple enough to be explainable in a way you all can appreciate. so, below, in its full glory, how Fable contributed to Bend's consistency proof, why that was 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 🫠

• 
  Nick Hazrd (@badhazrd) reported 27 minutes ago

  @GregTomaselli @github I think the biggest security issue is the fact that you won't get public or private.

• 
  John Kennedy Peterson (@skyshark88) reported 27 minutes ago

  @dair_ai •VALIDATED — the reproduction passed a could-have-failed test and is reproducible from the workspace. •ANCHORED — the result works consistently in the generated system (chosen value or implementation detail, not strictly derived). •CONJECTURE — motivated hypothesis still awaiting decisive test (used during spectrum exploration). •RETRACTED — permanently marked when evidence fails; status propagates to dependent claims. Claim type (routes effort): •Evidence-limited — additional runs or data improve the score (common for numerical fidelity claims). •Derivation-limited — only new logic, better specification, or a decisive experiment can raise the score. In the case studies, confirming data alone was treated as low-value; the system required genuine reproduction of the claim under the recorded provenance. Energy audit
Mention-count and emphasis in the paper versus actual effort invested (time, superseded executions, corrections) are tracked side-by-side with evidence status. Divergence between these columns signals potential error or under-specified claims in the original paper. Across the 12 runs, effort varied significantly (e.g., PINN papers required median 5–7 hours with more superseded executions; SINDy completed faster at ~2 hours). Key Evaluation Results (Mapped to Framework) •All 12 independent runs (3 per paper across 4 scientific ML papers: PIFT, PINN-I, PINN-II, SINDy) reached completion gate: every workspace had all targets matched with report coverage. •Total of 158 recorded targets were successfully linked to evidence. •Repeated runs showed natural variation in target decomposition, numerical fidelity, elapsed time, number of intermediate corrections, and exact acceptance rules used — exactly as expected when completion depends on workspace evidence rather than agent messaging. •Scalar results were largely faithful (37/39 anchored claims within thresholds), with positive headroom on several metrics. •The workflow makes replication inspectable and auditable, not a guarantee of identical numerical reproduction. Conclusion (Framework Perspective) By organizing replication explicitly around the Agentic Conversation Framework v3.0, Paper-replication becomes a concrete implementation of high-signal, bias-aware agentic work with computational chain of custody. Completion is a verifiable workspace state, not a subjective agent declaration. The framework’s dual histories, role separation, claim registry, scoring/pruning, and energy audit provide the missing structure that plain prompting lacks for long-horizon scientific replication tasks. This rewrite preserves all core contributions and empirical findings of the original paper while imposing the clearer, more auditable structure of Framework v3.0. The result is a more robust, inspectable process for turning paper claims into reproducible evidence. The original paper’s code, prompts, and workspaces remain available at the authors’ GitHub repository for further experimentation with this or future framework versions.

• 
  Jess Daniel (@jess_daniel10) reported 27 minutes ago

  @neetcode1 I was testing something with a local server and I told 5.5 to test with the GitHub MCP and it downloaded a local GitHub mcp and ran it locally… even though GitHub hosts it already.

• 
  Michael Liam (@Millionareum) reported 30 minutes ago

  I JUST FOUND SOMETHING THAT SHOULD BE VERY EXPENSIVE Running a company with zero employees. Here's what makes this possible: Paperclip. It's a 100% open source project on GitHub, with over 70,000 stars. I'm not talking about triggering a single model. You hire a CEO, you hire engineers, and you also hire a QA supervisor. Each worker is an artificial intelligence agent, and Paperclip is the Node that keeps them compatible.js and React control plane. Stop dealing with disorganized systems and build a living organization: - Establish a CEO agent for strategy. Hire engineers and designers through Claude or Codex. - Set up an automated QA cycle before any ticket is closed. Manage the entire portfolio from your phone. Do you know what you do when an agent makes a mistake? You're not rewriting the entire pipeline. You're just refining the persona instructions, like coaching a junior employee. This is exactly the kind of tool this field needs right now. Free, open source, can be hosted on your own server.

• 
  Patrick Barnhill (@Patrickbarnhill) reported 32 minutes ago

  DGX spark hosting main Hermes connected to telegram group chat threads. Honcho memory (just saw it was available trying it out hosted locally). Sharing to GitHub "agent ops" so other agents share important skills. Home computer running Hermes WSL and also windows native Hermes for computer control. Office PC running Hermes windows only for computer control. Daily driver codex gpt5.5. also running Qwen on DGX spark 1 and nemotron on DGX spark2 but with how inexpensive codex sub is with insane usage virtually no use for the DGX except for smart home if Internet is down

• 
  Nexis (@Nexisintel) reported 32 minutes ago

  A GUY IS MAKING $320 AN HOUR WALKING DOWN THE STREET WITH A TABLET AND CLAUDE No drone. No survey crew. No week of processing. Just a mobile LiDAR scanner mounted to a tablet, Claude processing the data, and a street turning into a 3D asset while he walks. The device captures the geometry around him in real time. Building facades. Doorframes. Sidewalk edges. Surface textures. Every wall, curb, and corner becomes part of a point cloud on the screen. Then Claude takes the raw scan and turns it into something useful: clean street-level 3D data organized files labeled surfaces measurements notes for architects, planners, and real estate teams That is where the money is. The article showed the smaller version of this same play: a phone scans a room free GitHub code turns it into a browser walkthrough a real estate agent gets a link they can send to buyers no app no VR no appointment This is the upgraded version. Instead of scanning one room, he scans full streets. Instead of selling a virtual tour, he sells usable 3D datasets. Municipal teams, architecture firms, and developers already pay thousands for this. He charges $320/hour and delivers the files the next morning. The crazy part is not the scanner. It is the business model. Walk through the city once. Turn the physical world into data. Sell the data to people who used to hire a whole crew to collect it. Most people see a guy holding a tablet. Clients see a cheaper survey team.

• 
  StonedModder (@StonedModder) reported 33 minutes ago

  @mac_shirk The openpuck project on github fixes this issue I’ve been using it to spoof my steam controller to a dualsense 3 for my PS3

• 
  Tamara Martinović (@CodeWithTamara) reported 36 minutes ago

  @kushmergedeck Stacklight. An email each day with updates on the stack you use - from Vercel and Github, to OpenAI and Anthropic. What's new, what's deprecated, what's broken. Scanning every 15 min. A Slack alert for the red warnings. What do you think, would people build their own rather then pay for mine? That's what worries me.

• 
  wats🏳️‍🌈 (@Watsonage) reported 38 minutes ago

  @CheetahGirlsYea it's kind of hard to find actually it got taken down from the app stores and then even github, I'll find the right link for you later

• 
  Harry Tandy (@HarryTandy) reported 41 minutes ago

  Boris Cherny, creator of Claude Code: "Usually, every night, I have like a few thousand that are doing kind of deeper work" Anthropic's reported 8x coding output starts before Claude writes a line Build the context stack: 1. `CLAUDE.md` - role, repo rules, code style - commands Claude should run before a PR 2. `@AGENTS.md` import - if your repo already has agent rules - keep Claude-specific notes below the import 3. Architecture map - where frontend, backend, tests, auth, billing live - which folders need approval before edits 4. Task packet - ticket link, files, goal, constraints - exact definition of done 5. Past attempts - what failed last time - what error or review comment caused the retry 6. Tool context - GitHub for issues and PRs - Sentry for live errors - Postgres for schema checks 7. Verification - one command Claude can run - one pass/fail result it can paste back 8. Post-run memory - add the lesson to auto memory or `CLAUDE.md` - remove rules that no longer help A prompt asks for work. A context stack gives Claude the room to finish it

• 
  Ask GPTs (@askgpts) reported 44 minutes ago

  Alibaba just released a browser automation tool that works completely differently from everything else out there. It's called PageAgent and instead of controlling your browser from the outside like Selenium or Playwright, it lives inside the webpage itself as plain JavaScript. Here's why that matters: - No screenshots required — it reads the actual page structure directly - Works with your existing login sessions automatically - Much cheaper to run — no expensive vision AI models needed - Faster and more precise than screenshot-based agents - Works with Claude, ChatGPT, DeepSeek, Gemini, or any local AI model - One line of code to add to any website - Completely free under MIT license Traditional browser automation tools all work the same way: run something external that takes screenshots and guesses what to click. PageAgent reads the actual page structure like a human reading text. 15,000 GitHub stars in weeks. Most people in tech haven't heard of this yet.

• 
  Milo Shrike (@milo_shrike) reported 44 minutes ago

  @IamAroke I had to shut it down when it was introduced to our architecture. Was not needed just “shiny”… good times. GitHub was pushing it big time at one point then nothing

• 
  Waldemar Enns (@WaldemarEnns) reported 44 minutes ago

  @claudeai I really do not get the hype of Claude Tag. Months ago I used a simple GitHub App Integration to be triggered by mentions which hit my openclaw code agent and it used advanced looping techniques to implement festures, triage tickets and fix bugs. Am I missing something here?

• 
  Devin Gunay (@devingunay) reported 45 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"

• 
  Vladimir Sapronov (@v_sapronov) reported 45 minutes ago

  @stolinski You will never understand. Because you are too far from real devs and their real problems with GitHub. As a result you are tone deaf when baiting their cheap marketing...

• 
  Ryan Lelek (@ryanlelek) reported 46 minutes ago

  @github April 1st was months ago. Fix your uptime

• 
  Matt Teixeira (@matt_teeixeira) reported 48 minutes ago

  Is there nothing else to do at GitHub? Like availability issues?

• 
  Paul Solt (@PaulSolt) reported 48 minutes ago

  @guitaripod The root of my problem is making agents create PRs with images, so I can quickly verify my iOS and macOS apps. There are workarounds and none are great for something that should just work on @github

• 
  Danny 🏴󠁧󠁢󠁷󠁬󠁳󠁿 (@danjones) reported 49 minutes ago

  @stolinski @v_sapronov @rpunkfu Again, you said it yourself. It's cheap. Completely get why you would get hyped over it. But there's much deeper issues within GitHub, this is simply PR/ Marketing to mask over that. Feel free to tell me otherwise.

• 
  Duke Magus (@dukemagus) reported 50 minutes ago

  @ClassicREbirth Oh HELL no. They're part of the problem, Microsoft stripmined GitHub to fuel the AI craze that drove prices up and it's a big domino in this whole thing. They don't get a pass to make this joke.

• 
  netrunner (@netrunner_btc) reported 51 minutes ago

  @2xnmore swe-bench is narrow github issue fixing, none of that measures if the agent survives a real codebase or ships without breaking ****

• 
  Mvykool (@mvyk0l) reported 56 minutes ago

  Why can’t they just fix Windows and GitHub???

• 
  Sergio Gómez (@sgomez) reported 60 minutes ago

  The flow: I write the PRD with Matt's /to-prd skill and break it into GitHub sub-issues. Then, for each one, a dispatcher picks the right model, a code author opens a PR in an isolated worktree, a reviewer approves or asks for fixes, and the loop merges and moves on.