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:

• 
  Zed (@thezlatkom) reported 2 minutes ago

  @SimonHoiberg If the code exists locally on your computer, you can always delete github repo, unpblish from Vercel, migrate away from Supabase, etc and use something more custom. These problems aren't unsolvable.

• 
  Matt Teixeira (@matt_teeixeira) reported 3 minutes ago

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

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

• 
  Techjunkie Aman (@Techjunkie_Aman) reported 6 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.

• 
  FHILY👑 (@Oluwaphilemon1) reported 10 minutes ago

  JUST IN: Claude Fable 5 and GPT-5.6 are cooked. A Netflix engineer just open-sourced a tool that can cut LLM token usage by up to 95% - without changing your code 😳 Headroom, built by Netflix engineer Tejas Chopra, sits in front of tools like Claude, Cursor, Codex, and other agents as a local proxy. Before your payload hits the model, Headroom compresses the context. Not by blindly chopping it down. By using specialized compressors for different payloads: → SmartCrusher for JSON → AST-based compression for code → Tool-output and log compression → Local reversible storage of originals → Agent wrappers that make it usable without rewriting your app The headline claim is 60–95% fewer input tokens while preserving answer quality. The repo has already crossed 42K+ GitHub stars, which says something obvious: Developers are not just worried about AI getting smarter. They’re worried about AI getting expensive. Of course, compression is not free magic. Complex reasoning tasks may punish missing context. Agent loops may behave differently. Proxy overhead has to be worth it. And real-world savings will vary. But the direction is clear - the next big AI infra unlock may not be a bigger model. It may be learning how to stop feeding expensive models cheap junk. Because the cheapest AI inference is the context you never send.

• 
  Aithne (@aithne_desert) reported 11 minutes ago

  @michaelvessia @github i was watering the pothos when github went down again and now im convinced the whole team is just in a group call refusing to push anything till someone brings snacks

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

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

• 
  One&OnlyAarav (@WaterAarav) reported 12 minutes ago

  Claude = coding. ($20/mo) Shypmenta = fully automates platforms below($6/yr) Supabase = backend. (Free) Vercel = deploying. (Free) Namecheap = domain. ($12/yr) Stripe = payments. (2.9%/transaction) GitHub = version control. (Free) Resend = emails. (Free) Clerk = auth. (Free) Cloudflare = DNS. (Free) PostHog = analytics. (Free) Sentry = error tracking. (Free) Upstash = Redis. (Free) Pinecone = vector DB. (Free) Total monthly cost to run a startup: ~$20. Building has genuinely never been this affordable, and rarely this effortless either.

• 
  RichiΞRich 🐂🀄️🦅🇺🇸🪽 (@stillrichierich) reported 13 minutes ago

  @BrantlyMillegan @ethidorg so we vamp the prediction markets now ? If you are down to look at my github maybe you guys build out my private repo and we send eth to ATH. Would love your opinion at the very least 🤙

• 
  Dishant Miyani (@dishantwt_) reported 16 minutes ago

  @samposwal @github i hope they fix their downtime first

• 
  Mvykool (@mvyk0l) reported 18 minutes ago

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

• 
  David Sancho (@davesnx) reported 18 minutes ago

  true true, but later you need to turn the notes into your obsidian todos: take a picture, run ocr, run a local model to rewrite your todos with better context, store it into your *** repository, in a state-of-the-art setup you would create github issues for each, and forget about markdown files once the issues are there, we have a scrum-master-reviewer that analyzes the dependencies, and pings the next agent, nuclear-architect-lead which creates the diagrams, the arrows, and talks with the 2nd agent architect about the components this 2nd agent is the scalability-expert and they discuss for 10 minutes (tokkenmaxxing here) if the solution is scalable then the scalability-expert escalates to the vp-of-agents (also an agent) which spins up 6 fables that implements the features, and deploys into your k8s cluster meanwhile a rag pipeline embeds the logs/conversations/issues and the plans into pgvector (512 token chunks, 20% overlap obviously) so the memory-curator can do semantic search over "lets add a feature to buy milk", the standup-summarizer writes a 4-page RFC about the milk, reviewed by 3 critic agents (adversarial, constructive, and one that only says LGTM to keep morale up), the eval-harness runs 400 test cases against your todo list, traces go to grafana, and a finetuned 70B decides the milk is out of scope for this sprint $340 in tokens and 6 hours of wall-clock time later I call it... the productivity hack

• 
  99Barz (@99barzzz) reported 20 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 the keeper on autopilot as github actions... on github infra! added to the backlog

• 
  Arshad Kazmi (@arshadkazmi42) reported 21 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.

• 
  Andrew Darius (@andrewdariuscom) reported 22 minutes ago

  Mistral just dropped Leanstral 1.5 — a free open-source 6B model. It solved 587/672 Putnam competition problems (hardest undergrad math on the planet). Then they ran it against 57 real GitHub repos. It found 5 bugs nobody had ever reported. Agentic proof engineering. Apache 2.0. Run it on your own machine. Mathematician + bug hunter. In one open model.