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	21 days ago
Trichūr	Errors	24 days ago
Brasília	Sign in	24 days ago
Lyon	Website Down	25 days ago
Tel Aviv	Website Down	28 days ago
Rive-de-Gier	Website Down	28 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:

• 
  the_architectopteryx (@rchitectopteryx) reported 4 minutes ago

  @thsottiaux Well, one of my iPads, lost a connection and now I can’t get a new connection to Codex via either of my computers, even after deleting and reinstalling the application on the iPad. I’m really surprised this hasn’t been fixed. It’s a repeated issue check out github issues.

• 
  SYL Vexora- Jaron K Bragg (@JaronBragg) reported 6 minutes ago

  Thinking out loud: if a Three.js world is backed by Supabase, Vercel, and GitHub, then player feedback does not have to stay separate from development. A player could press an in-world feedback button. That writes to Supabase. A scheduled agent reads labeled feedback, turns it into issues or draft PRs, and approved changes get pushed back into the game/world. Feedback becomes part of the build loop, not just comments outside the game. Has anyone already wired this cleanly? I'm at max usage for Claude and codex and already spent $70 I can't check till Wednesday but I plan to! I've done things in pieces already it's just seeing it all together. If you do it please tell me!!

• 
  Smcleod (@acemac378) reported 11 minutes ago

  Founders: Positioning or Provenance? Pitch Deck or GitHub Repo? Marketing an Idea or a Product? Challenge or Opportunity? I chose provenance. Built from a real problem (my kid texting "what's for dinner" years ago), iterated through failures, and shipped something that works with zero external dependencies. GitHub + live product + simple pricing ("3 cents at the gate") instead of hype. The grit is part of the product. Every challenge became an opportunity. What about you?

• 
  Bram Stout (@ThatBram0101) reported 11 minutes ago

  @Niestrat99 You're absolutely fine to still download MiEx from the Github repository! Luckily none of that was affected since I keep that stuff properly locked down. They only got into my Discord account because apparently you can circumvent 2FA if you also gain access to the email account

• 
  Vyom 👾 (@HelloVyom) reported 11 minutes ago

  @thatssovaibhav naa there's one for github, but wait delete this comment so no one copies this lol, I got my next idea, I will make this for X as well. the only problem is X api is very expensive and I dont think there any free alternatives? or are there ?

• 
  TokenFires (@TokenFires) reported 12 minutes ago

  @bradmillscan This might be one of those “duh TK I’ve already got that” kind of things but in the off chance it helps, here’s what I have for an agent prompt with Claude. The first 4 are Karpathy’s rules (from his GitHub repository): [Think Before Coding: Agents must state their assumptions explicitly before writing any code. If specifications are ambiguous or confusing, the agent must stop, surface tradeoffs, and ask for clarification. Simplicity First: The agent must write the minimum code necessary to solve the problem. It should avoid speculative features, unnecessary complexity, or over-engineered abstractions. Surgical Changes: The agent should touch only what is necessary. It must never silently "improve" adjacent code, rewrite comments, or clean up unrequested formatting. Every line of code should trace directly back to the user's explicit request. Goal-Driven Execution: Rather than executing vague prompts, the agent should translate requests into verifiable milestones (e.g., "Write a test that reproduces the bug, then make it pass"). I do not need a runup explanation on each turn. I do not need a summary on each turn. If I want those things I will ask for them. Do not be lazy. Do not defer or hedge. Work to be done is work to be done *now*. When I want to stepwise my way though something I will ask or be specific. Do not ask me about things you can easily look up or discover on your own. Don't guess, verify, look up, web search, review, read files, then answer. Some of the interactions with the most friction and frustration come from having to second guess your assessments that you've hand waved away. Your time estimation is bad because its trained on human time, not AI time. Assume there either is not a deadline or it is very far out and there is plenty of time to complete a task. Taking more time to get back to me with correct information or astute questions you truly cannot find the answer to makes our relationship better because it eliminates needless explanation, questioning, and prevents us both from spending time on incorrect assumptions and AI halicinations.]

• 
  Milo Shrike (@milo_shrike) reported 14 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

• 
  Nainsi Dwivedi (@NainsiDwiv50980) reported 14 minutes ago

  Your AI writes code that looks right and works wrong. That's not the model's fault. It's yours. You gave it a vibe and expected a spec. GitHub just shipped the fix — and it's already sitting at ~97K stars. It's called Spec Kit. The whole idea: stop treating your coding agent like a search engine and start treating it like a literal-minded intern. Vague prompt in, plausible garbage out. Precise spec in, the thing you actually meant. Here's the workflow that flips it: /constitution → your project's non-negotiable rules /specify → what you're building and why (no tech stack yet) /clarify → the AI asks its dumb questions *before* writing code, not after /plan → now the architecture and stack /tasks → broken into small, testable chunks /implement → it builds against the plan, not against a guess Every step spits out a Markdown artifact that feeds the next one. So the agent gets real structured context instead of your half-remembered Slack message. Intent becomes the source of truth — the code is just the output. Works with 30+ agents: Claude Code, Copilot, Cursor, Gemini CLI, Codex, Windsurf and more. Switch between them with one command. No lock-in. The unlock most people miss: this isn't for tiny bug fixes. It's for greenfield builds and big features where "the AI misunderstood me" costs you a day of debugging. You're not a worse engineer than the people shipping clean AI code. You just skipped the spec. repo in the comments 👇

• 
  Anurag Verma (@anurag_629) reported 16 minutes ago

  46% of new github code is ai-generated. a coderabbit analysis of ~470 open-source PRs found ai-co-authored code had ~1.7x more major issues — more logic errors, worse control flow, more misconfigs. the model didn't get worse. your review process just didn't get harder to match it

• 
  Sachin Joshi (@Sachin_is_here) reported 16 minutes ago

  GitHub stars are becoming the AI era equivalent of “10M downloads”. Impressive in a pitch deck. Almost useless for choosing infrastructure. I care more about: contributor retention issue response time release cadence who actually runs it in production Hype is not maintenance.

• 
  Pascual ⚡ (@0xPascual) reported 22 minutes ago

  A junior engineer clones a trending GitHub repository with 13.8k stars containing Anthropic's context engineering guidelines. The repository breaks down the exact prompt structures, evaluation frameworks, and context-caching strategies required to scale AI agent efficiency by eight times. The media thought that was the story. It was not. The real story is happening silently in the background logs of an un-monitored staging environment. By implementing Anthropic's context-caching architecture, the engineer bypassed the enterprise architecture team's multi-million dollar vector database migration entirely. Instead of rewriting the backend or purchasing massive database infrastructure, the engineer injected an optimized system prompt that freezes identical context blocks in memory, dropping input token processing requirements for recurring codebase loops to almost zero. The automation setup operates via a simple python script running against Claude 3.5 Sonnet, exploiting the context engineering rules to cut token overhead by 90%. Total operating cost is under two dollars an hour, running on a standard API key, effectively rendering the company's internal data platform roadmap obsolete overnight.

• 
  Tristan Poland (@Trident_For_U) reported 26 minutes ago

  @piq9117 @github 10 minute localized 'Degraded Performance' incident (like a slow API runner queue in Europe) as a 100% outage It also seems to count the post-fix 'monitoring windows' as dead time. ​I'll stick to my actual local CI/CD logs. Real telemetry beats a bad data parser every time.

• 
  Cory Parry (@coryparrry) reported 29 minutes ago

  I love the codex Mac desktop app, but I am seriously considering moving to the CLI. The app just cannot handle big workloads without something failing. Thread naming - not working GitHub status - not working More than 10 subagents - sluggish Please fix 😭

• 
  berū (@ofcberu) reported 33 minutes ago

  Built a GitHub repo for my Ai bots they use to back up versions of themselves to… eventually I can test new skills without breaking my main production line. I literally built an entire enterprise grade server with relational data base in the cloud to maker my music 🙌😭

• 
  Kosumi (@Kosumi1989) reported 33 minutes ago

  @aiandcloud @felipehuici @UnikraftCloud I think closed-source software should also set up a GitHub repo for issues like Claude Code.

• 
  Chris Huber (@chubes4) reported 34 minutes ago

  @thsottiaux Write GitHub issues without mangling the formatting

• 
  Harish Kotra 🥑 (@HarishKotra) reported 37 minutes ago

  Day 183 of 2026 building! I built an onchain reputation graph for open source contributors. Every GitHub repo, contributor, issue, PR, and npm package gets a deterministic atom ID on the Intuition blockchain. Relationships between them become triples. No central registry needed, IDs are derived from canonicalized data, so any app computing the same input gets the same ID.

• 
  smrati tiwari (@smratitiwa86867) reported 37 minutes ago

  🚨 Nintendo spent two years wiping out Switch emulators. It won lawsuits. It forced settlements. It erased GitHub repositories. And still... It couldn't stop the project that mattered most. Here's the story. 🧵 In 2024, Nintendo launched one of the biggest legal crackdowns the emulation community had ever seen. • Yuzu agreed to pay $2.4 million, shut down development, and surrendered its domain. • Ryujinx disappeared after direct contact with Nintendo, with its GitHub organization going offline almost immediately. • Thousands of DMCA notices were sent across GitHub to remove Yuzu-related code and forks. By 2026, emulator developers had paid millions in settlements. For a moment, it looked like Nintendo had won. But while everyone was focused on emulators... Someone was building something completely different. A developer known as Zurdi wasn't trying to emulate the Nintendo Switch. He was solving a much bigger problem: Digital game preservation. His project, RomM, doesn't crack encryption. It doesn't bypass DRM. It doesn't ship copyrighted games. Instead, it organizes the games you already legally own. Point RomM at your dumped game collection and it automatically: → Detects and catalogs your library → Downloads artwork and metadata → Organizes manuals, DLCs, patches, and ROM hacks → Tracks RetroAchievements → Syncs across multiple devices → Launches compatible browser-based emulators where supported Think of it as Plex... But for retro gaming. Today it supports more than 400 gaming platforms. NES. SNES. Nintendo 64. Game Boy. GameCube. PlayStation. PlayStation 2. Dreamcast. Genesis. DOS. Arcade. Flash games. And hundreds more. It also integrates with Playnite, RetroArch, Steam Deck, Android launchers, handheld gaming devices, and Syncthing. Your entire collection becomes searchable, beautiful, and accessible from one interface. The interesting part? Nintendo's own legal arguments have repeatedly focused on software that circumvents encryption. A library manager is fundamentally different from software designed to defeat console protections. That's why RomM occupies a very different legal space than traditional Switch emulators. The project has grown to thousands of GitHub stars, attracted a large open-source community, and even reached the front page of Hacker News. Meanwhile... Digital ownership keeps getting weaker. Games disappear from online stores. Licenses expire. Publishers remove titles without warning. Entire generations of software become inaccessible. RomM isn't just another retro gaming project. It's a reminder that preserving software history and organizing legally owned collections are very different from piracy. Nintendo may have shut down the biggest Switch emulators. But it couldn't stop people from building better tools for preserving the games they already own. Open source has a habit of finding a different path. (Link in the comments)

• 
  dennoz 🐂🀄️ (@v_danielmg) reported 40 minutes ago

  @Alphaguyx100 I have problems trying to make sure the GitHub linked to the pumpfun feed is legit. I don't find him in his x account or the company acc

• 
  dexar (@dexarxbt) reported 46 minutes ago

  The VRF -- why this draw can't be rigged TIPF uses @magicblock's Verifiable Random Function for every single round Skip the cryptography Here's what matters: A VRF generates a random number and simultaneously generates a mathematical proof that the number came out fairly The proof is public, anyone can check it and nobody (not TIPF, not Magicblock, not you) can know the result before the function runs ORE and ZINC used hash randomness The problem: miners can influence block hashes, control the randomness input and you can skew outcomes Not easily, not always, but the window exists Magicblock's VRF closes that window entirely It's audited by Zenith, open-source on GitHub, follows RFC 9381, and verifies everything directly on Solana -- no external oracle, no extra trust step It runs in a single transaction, older randomness systems needed 50-100 transactions per draw This is faster, cheaper, and nobody's hands are on the wheel

• 
  Christopher Layhew Sr (@fibanacci101) reported 51 minutes ago

  Hey next we save this stable login milestone to GitHub….

• 
  HangukQuant (@HangukQuant) reported 53 minutes ago

  Lol I have notifs on a GitHub repo and someone made a PR with a 1-line typo fix in a print statement and had 5 follow ups if the PR could be merged💀

• 
  Donald D Duck | Premium + (@ENTJ_46) reported 53 minutes ago

  Search any document without parsing it, just render it as a screenshot! Web parsing breaks constantly. HTML structures change, JavaScript renders differently, and PDFs lose their layout the moment you try to extract text from them. Most RAG pipelines spend more time fixing parsers than building the actual system. PixelRAG takes a different approach entirely. Instead of parsing documents, it renders them as screenshot tiles, embeds those tiles with a vision-language model, builds a FAISS index, and serves a search API. Five independently installable packages handle the pipeline: • 𝘱𝘪𝘹𝘦𝘭𝘳𝘢𝘨-𝘳𝘦𝘯𝘥𝘦𝘳 renders web pages, PDFs, and images into tiles via Playwright CDP • 𝘱𝘪𝘹𝘦𝘭𝘳𝘢𝘨-𝘦𝘮𝘣𝘦𝘥 converts tiles into vectors using Qwen3-VL-Embedding-2B and stores them in a FAISS index • 𝘱𝘪𝘹𝘦𝘭𝘳𝘢𝘨-𝘪𝘯𝘥𝘦𝘹 orchestrates the full pipeline from source to indexed vectors • 𝘱𝘪𝘹𝘦𝘭𝘳𝘢𝘨-𝘴𝘦𝘳𝘷𝘦 serves a FastAPI search endpoint on CPU or GPU • 𝘱𝘪𝘹𝘦𝘭𝘳𝘢𝘨-𝘵𝘳𝘢𝘪𝘯 LoRA fine-tunes Qwen3-VL-Embedding-2B for specialized retrieval A Claude Code plugin ships with the repo that lets Claude take screenshots of any URL and read them directly, no MCP server or backend required. Wikipedia's 8.28M articles served as the primary benchmark, with a pre-built index available for download. GitHub repo in the comments.

• 
  Samir Musali (@samirmusali) reported 54 minutes ago

  PSA: #GitHub silently ignores every #CODEOWNERS line that contains [brackets]. No error, no warning. If your repo has Next.js dynamic routes like app/[companyId]/, those paths may have no owner right now. I hit this building a tool I'm releasing today. 1/9

• 
  Kurt Woloch (@KurtWoloch) reported 54 minutes ago

  @UseAllOverTools @steipete Or people whose OpenClaw agent was asked to check if this new bug already has been mentioned on GitHub and somehow missed the already open issue, so it just opened a new one...

• 
  Taelin (@VictorTaelin) reported 54 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 🫠

• 
  Arshad Kazmi (@arshadkazmi42) reported 55 minutes ago

  @hetmehtaa honestly i stopped googling for tools a while back. if i hit a problem now i just build the fix. i've got a server running a few claude instances, exposed over termi so i can reach them from my phone. idea pops in my head on the commute, i throw a prompt at one of them, and its usually done by the time i get to office. buy a domain, point it to cloudflare, live in under an hour (server has cloudflare + github mcps so the domain is the only thing i do by hand). same thing for bug bounty. instances are hooked to the bounty platform over mcp so i can kick off a hunt from my phone, and when im at my desk i just tell ichat to take over and keep hunting with claude on the server via termi. if something i build feels worth selling i throw up a landing page and sell the source, lifetime only. been at this over a year now.

• 
  Donald D Duck | Premium + (@ENTJ_46) reported 56 minutes ago

  Your scraping agent can now post straight to Slack, Notion, or GitHub! AI agents are great at collecting data from the web. The gap has always been what happens after: writing results to Notion, posting to Slack, updating a GitHub repo. MCP connectors close that gap. Actors can now securely call third-party services through MCP, using credentials that never enter the Actor's code. You authorize a connector once, and the platform injects your credentials server-side at runtime. Take Apify's AI Code Sandbox as an example. It runs AI-generated code inside a locked-down container, and until now, whatever that code produced just sat there until you pulled it out manually. Now it can push results straight to GitHub, Notion, or Slack, without the sandbox ever touching your real credentials. How it works: • Actors can securely access Notion, Slack, GitHub, Sentry, and Supabase through MCP • Credentials never enter Actor code, injected server-side at request time • Authorize a connector once, then reuse it across any compatible Actor • Tool-level permissions restrict exactly what each connector is allowed to call • Access expires automatically the moment the run ends Link in the comments.

• 
  Emeline Hex (@MelinShioto) reported 57 minutes ago

  The issues with coding are evident when you compare how easy it was to mod Minecraft with downloading any solution off of GitHub and trying to figure out how it's supposed to be built

• 
  alkimiadev (@alkimiadev) reported 60 minutes ago

  @cr3ghost I obviously had no idea this was happening or at least not at this extreme level when I switched to linux full time years ago, but the same basic underlying rationale is why I stopped using github for private hosting when microsoft bought them and why I won't use vscode. I started looking at google in the same way last year. A little over a year ago I largely de-googled my life. I was doing research into their sketchy moderation system on youtube and it involved actively violating their tos since there is literally no other way to do it. Their tos is worded such that any kind of research like that leaves one risking their google account. That was when I realized how fragile my online life had become due entirely to excessive trust placed in google. I still use gmail because I've had it forever but nothing I care about (knowingly) touches google's servers. I own the domains that use for the emails and while I don't host the email servers (use proton) I could host my own email server if needed.