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:

• 
  Techjunkie Aman (@Techjunkie_Aman) reported 2 minutes ago

  It's June 2020. European Space Agency engineer Juan Font Alonso loves Tailscale. WireGuard has never been easier to use. But one thing bothers him. The encrypted tunnels are open source. The control plane isn't. Authentication, key exchange, IP assignment, ACLs, and network coordination still rely on Tailscale's proprietary server. For self-hosting enthusiasts, there was no alternative. So instead of waiting, Juan built one. That project became **Headscale**, a clean-room, self-hosted implementation of the Tailscale control server. Built from public protocols, not copied code. The best part? Tailscale welcomed it. They praised Headscale publicly, and today both projects actively work to maintain compatibility. What started as one engineer's homelab project is now the go-to self-hosted control plane for thousands of users. **Why people use Headscale:** • Self-host your own Tailscale-compatible control server • Keep authentication, keys, and network metadata private • MagicDNS, ACLs, Grants, subnet routers, and exit nodes • OIDC authentication and SSH approval workflows • REST API, Docker, Kubernetes, NixOS, and systemd support • 40K+ GitHub stars and hundreds of contributors Sometimes the best open-source projects aren't built to replace something. They're built to give people ownership over the part that mattered most.

• 
  Lexor (@RexAdamantium) reported 4 minutes ago

  @iruletheworldmo @petergyang For business coding, Microsoft’s answer to Codex is basically GitHub Copilot Business or Enterprise, but strangely, it sits outside the Microsoft 365 Copilot/Office stack. Google has Antigravity. Anthropic has Claude Code/Enterprise. Then there are tools like Cursor. For companies, the problem is not lack of options. It is that every option comes with a trade-off. The real question isn’t which AI is smartest. It’s how much speed you’re willing to buy by leaking IP.

• 
  X Crypto (@XCryptozc) reported 6 minutes ago

  Something just happened in Keeta's GitHub that most people will scroll past. A critical cryptographic bug was caught and fixed before it ever touched production. Let me explain why that matters Keeta is building a second version of its core infrastructure in Rust. Faster. More secure. Built for scale. Part of that work involves certificate signing. The process that proves a node on the network is who it says it is. Someone caught that the code was using the wrong hash algorithm. SHA2-256 instead of SHA3-256. In cryptography the wrong algorithm is not a minor issue. It affects node identity verification across the entire network. It was caught. Fixed. And shipped in node-rs v0.3.0 within the same cycle. Then the team went further. After the fix landed someone reviewed the code again and flagged that a verification function added alongside the fix was unnecessary. There is no situation where the elliptic curve would be unknown at signature validation time. The function was misleading and should not exist. So they opened an issue to remove it. That is not a team rushing to ship. That is a team that genuinely cares about getting the cryptographic layer right. Now the bigger news. anchor-rs is Keeta's Rust rewrite of its core payment anchor. It just switched to the real node-rs client for actual network calls. It is no longer running in isolation or against test mocks. It is talking to the live network. The Rust stack just went from prototype to real. And it is closing the gap with the existing TypeScript version fast. PR #15 adds missing methods, aligns the naming conventions, and plugs into the live node client. Two parallel stacks. Being built to match each other. One in TypeScript already in production. One in Rust catching up fast. On top of all that, profile client data is now being wired into the anchor storage layer. The transaction history grouping bug has been fixed. Certificate rotation in the cloud infrastructure is now version controlled. A critical crypto bug caught before production. The Rust anchor talking to the live network. Security reviewed twice in the same release cycle. This is not a team coasting. This is a team locking everything down before the real scale begins. $KTA @KeetaNetwork

• 
  Dev Palwar (@devpalwar06) reported 8 minutes ago

  github down again?

• 
  Arjun Shah (@arjunkshah21) reported 13 minutes ago

  THIS GUY SHIPPED 4 FULL-STACK PRODUCTS IN 3 MONTHS WITH CODING AGENTS, THEN WATCHED HIS WHOLE TEAM SHIP UNMERGEABLE SLOP, SO HE VIBE CODED THE INFRA TO FIX IT every repo needed an engineer doing one-off local setup just to spin up an agent session skills and context lived in one person's head, and there was no safe way for a pm to touch a real codebase without risking a bad deploy or secrets leak its called runtime and it lets your whole team ship with claude code, codex, and other agents without engineering babysitting every run > engineering defines context once — system instructions, skills, and scoped integrations installable via cli, mise, or npm > snapshots your full running environment including docker compose, kafka, redis, and seeded dbs so sandboxes boot in milliseconds with every server already running > secrets injected through a managed proxy so they never touch the agent, with command allow/deny lists, network egress controls, and rbac scoped per human and per agent > every session gets a shareable preview url so internal builds go from sandbox to the team without production access > works with claude code, codex, cursor, copilot, gemini, and devin — trigger from slack, linear, github, or api > one customer wired pagerduty and sentry so when an alert fires the agent finds the cause and opens a pr with a unit test before anyone gets paged yc p26, open source core, orchestrates e2b daytona ec2 or self-hosted k8s, flat platform fee plus compute with no token markup crazy what you can build when agent workflows stop living in one engineer's head

• 
  Mohammad Anas (@mohmmad__anas) reported 15 minutes ago

  Agents Are Fine. Coordination Is The Problem. I downloaded OpenClaw last month. Spent two hours setting it up. The thing worked. It generated ideas, drafted threads, even picked images. And then I hit the wall. I had five agents now. Each one smart. Each one fast. But none of them knew what the other four were doing. I'd get three ideas from the brainstorm agent that contradicted the positioning the research agent had locked in. The video agent would commit to a script length the scheduling agent couldn't actually fit in the posting window. My approval process became a UN summit where every agent had a veto. The real problem with AI agents isn't capability. It's the coordination tax. Every new tool I add doesn't increase my output linearly. It increases my decision-making load exponentially. I now have to know what each agent is optimizing for, what constraints they respect, where they hand off to the next one. That's not automation. That's complexity I'm now responsible for managing. This is why most founders abandon multi-agent stacks within three months. Not because the agents are bad. Because humans are terrible at being the bus driver between independent smart systems. The winning move isn't smarter agents. It's agents that share a single source of truth about what you're actually trying to do. One brief. One command. One output format. Every agent reads the same schema, knows the same constraints, writes to the same state. That's when agents stop fighting and start building. I'm watching the GitHub trending list fill up with orchestration projects — Hermes Agent, Dify, n8n all gaining ground fast. They're not winning because they're smarter. They're winning because they solve the coordination problem. The solo founder's real productivity leap isn't one agent. It's one unified system where the agents coordinate without you playing referee. Most automation tools optimize for letting you type less. The ones that win optimize for letting you think less. That's the difference between a tool that saves you an hour and a tool that gives you back your focus.

• 
  Paul Solt (@PaulSolt) reported 15 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

• 
  Ali Mehdi Mukadam (@alimukadam) reported 17 minutes ago

  @trq212 Your weekly limits will burn away much faster during the limited availability if you aren't aware of this issue if you're running Fable as the lead agent with cheaper models like Sonnet doing work in the background problem: In one of the sessions, I noticed limits were burning through way faster, so I went digging through the transcripts when the main agent gives a job to a background model (like Sonnet, which I asked for to save tokens) and then comes back to give it more work, the background agent stops working on Sonnet and switches to Fable, the main agent's model it's not something you trigger by hand. the lead agent decides to check back in on its own as part of normal multi-agent work, so it just happens, with nothing on screen telling you it switched. in my case a task ran its first half on Sonnet exactly like I wanted, then silently ran the entire second half on Fable. It also dumps the cached context and rebuilds it from scratch, so you end up paying twice, once for the pricier model and once for the wasted cache. on limited availability and limits - that adds up quick my fix for now is a rule I dropped into my global CLAUDE.md so it doesn't recur: --------------- ## Model spend (all projects, all repos — standing rule) - Dispatching Frontier-tier (Fable/Opus) as background tasks and agents needs explicit approval by Ali for that specific lane — a prior approval is not standing permission for the next one. - Never resume a background agent via a message-passing tool that has no model-override param (e.g. SendMessage) if it needs real further work — it silently inherits whatever model the parent session is on right now. Let it finish and report, or kill it and respawn fresh with the model set explicitly. --------------- in plain terms: don't let a background agent get pulled back in for more work once it's running. either let it finish and report back, or kill it and start a fresh one with the model set on purpose. And this is already known. Someone reported the same thing on GitHub back on June 12, issue anthropics/claude-code#67794, still open their solution which I believe is the correct one but haven't tested yet: instead of setting the cheaper model when you launch the agent, pin it inside the agent's own definition file, and that version reportedly sticks even when the agent gets resumed

• 
  Donald D Duck | Premium + (@ENTJ_46) reported 18 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.

• 
  Vladimir Sapronov (@v_sapronov) reported 18 minutes ago

  @stolinski @danjones @rpunkfu The famous infinite loop GitHub Actions wait bug (the timeout comparison is made with exact equality instead of more or equal) could be fixed by a junior dev with Claude in like 1 month including onboarding and Jira setup. That one junior costs a fraction of the single marketing manager whose job is "how to cover recent 88.88% stability ****** with burn-the-CD marketing, and then push this marketing down developers throats through a network of overly friendly influencers". And this is just the marketing manager, there were also artists, video production, legal, SMM manager - all paid employees who didn't work on the product this month (or ever). The influencer's servility is not quantifiable though - they are kneeling in exchange of having access to GitHub people for their podcasts to farm more Github-friendly content.

• 
  Olalekan (@lekodes) reported 19 minutes ago

  @pamilhereen @RoseMarvelous4 which i definitely have at the moment, github has being reject my push due to package-lock.json issue

• 
  Flavius Dinu (@flaviuscdinu) reported 21 minutes ago

  @SimonHoiberg Apart from Windows, everything else is pretty okay. Well, GitHub had some reliability issues, VSCode has two hundred forks, and my reach on LinkedIn is terrible nowadays, even if I have almost 15k followers.

• 
  2xnmore (@2xnmore) reported 23 minutes ago

  Billion-dollar AI labs spent months and hundreds of millions to hit this number. A crowd of anonymous strangers matched it in 45 days for under $1 million. Here is the story, because it explains what $TAO actually is better than any price chart. SWE-bench is the benchmark for AI coding agents. It measures how many real GitHub problems an agent can actually fix. The best centralised labs treat a high score here as a billion-dollar achievement. Then a Bittensor subnet called Ridges hit 80% on it. Not a company. An open competition where anyone on Earth can read the top agent's code, improve one weak line, and if their version wins, they take the entire prize for that round. Over $10,000 a day, paid directly, no interview, no boss, no permission. That single design is the whole thesis. The founder of Bittensor calls it an incentive computer. Bitcoin pays people to produce hashes. Bittensor pays people to produce anything you can measure and score. Coding agents. Trained models. Drug molecules. Weather forecasts. Define the work, score it, and a global army competes at it 24 hours a day. This is why it can pressure the giants in a way a normal startup never could. A centralised lab pays salaries and caps upside. Bittensor pays whoever is genuinely best, right now, from anywhere, with no ceiling. That is how an open crowd matched elite labs in 45 days on a rounding error of their budget. Here is the part nobody says out loud. The default AI future has a handful of companies owning the only minds that matter, and the rest of us renting access or getting replaced. That world is being built right now with your subscription money. Bittensor is the bet that a network can out-build a corporation, the same way Bitcoin proved a network can outlast a central bank. Most people judge $TAO by the candles. The people paying attention are watching an open crowd match billion-dollar labs and get paid for it. Which future do you actually want to own a piece of?

• 
  C-Man (@C_Man_The_Man) reported 26 minutes ago

  @DcentralizedRob @github Followed you back 🫡, is Streamr a lost cause? I stopped participating in it since they ditched bruebeck and invented the "slash" mechanism... it didn't seem right, there's so much drama in their server right now

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