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:

• 
  Assim Genshi (@AssimGenshi) reported 5 minutes ago

  @aryanranderiya @github Whaaat? I thought that the problem in my end, turns u have the same problem??!

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

• 
  d👁️x👁️r (@dexer_matters) reported 5 minutes ago

  @BaissariJean check my github profile. there's something like "the most boring server in the world"

• 
  John Papa (@SublimeTrades) reported 6 minutes ago

  Been using this short window we have access to Fable 5 with the paid subscriptions to do high level design and architecture discussions with HLDs and GitHub issues as the outcome of the sessions. Seems a waste to have Fable actually code with how fast it burns tokens.

• 
  Stay Tru Mining (@StayTruMining) reported 10 minutes ago

  I purchased the big screen and the board separately. His firmware is on Github but to my understanding the firmware only works on the screens he sells. Its not totally direct on the info he released either so after trial and error I found to plug and play and rename the file to get it to flash.

• 
  farxxxxx (@farxxxxx1) reported 13 minutes ago

  $29/month x 500 users = $14,500/month. That's the ceiling on a TikTok analytics tool I built from a free n8n scraper and one Claude Code session. > The product: type in a TikTok channel name, get back the hook structure, CTAs, and pacing behind their last 5 viral videos. Backend runs on n8n. Apify scrapes the channel. Gemini breaks down each video - hook type, structure, call to action. Data flows back through a webhook. The SaaS wrapper came from Claude Code. One PRD file, claude.md, holding the architecture, data schema, and stack. Next.js 14 for frontend and backend. Supabase for auth and database. Vercel for hosting. Webhook handles the connection. n8n sends results back through an HTTP Request node instead of the standard webhook response, so long AI processing never times out. Local testing ran through ngrok - fake public URL, real webhook calls, real bugs to fix. Every SQL error and mapping issue got fed straight back into Claude Code until it worked. UI came from a v0App design, rebuilt by Claude Code in under 10 minutes. Push to GitHub, connect Vercel, deploy. Swap localhost for the real domain in Supabase auth settings. Wire up Stripe. One session. One free workflow. A product that could charge real users real money.

• 
  Taelin (@VictorTaelin) reported 15 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 that said, 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 suspicious sometimes fortunately, Bend3's consistency proof is simple enough to fit a tweet and, and I'm happy to explain it in the most dumbed way possible. so, below I'll describe, in full extent, how Fable helped me on Bend's consistency proof, why it is incredible and, yes, 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 🫠

• 
  C-Man (@C_Man_The_Man) reported 16 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

• 
  99Barz (@99barzzz) reported 17 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

• 
  Vladimir Sapronov (@v_sapronov) reported 23 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...

• 
  Gofra (@Gofralo) reported 23 minutes ago

  In November 2025, a man who had already sold his company for $800 million sat down alone to build something new. He did not have a team. He had sold his previous company after years of building it with hundreds of people. The exit was clean. The number was real. He went on vacation, then another vacation, and then another. He was bored. So he sat down and built a tool that let an AI assistant live on your computer and talk to you through the apps you already used. WhatsApp. Telegram. Signal. iMessage. Not a new app. Not a platform. The AI came to where you already were. He called it OpenClaw. And then something happened that has not happened before. In 84 days, OpenClaw accumulated more GitHub stars than React had collected in ten years. React. The library that powers some of the most visited websites on earth. The project that hundreds of thousands of developers had bookmarked, referenced, and starred across an entire decade of web development. 84 days. And here is where it gets strange. He was not trying to go viral. He was not on a fundraising tour. He had no investors. He had no press strategy. He was a man who had already won, tinkering alone, building something he personally wanted to exist. On February 15, 2026, Sam Altman posted on X. Peter Steinberger was joining OpenAI. The most powerful AI company in the world had come looking for the man who was just tinkering. And now the main thing. This is not a story about GitHub stars. It is not a story about an acquisition. It is a story about what the bottleneck actually is. For thirty years, the bottleneck was team size. You needed engineers to ship, designers to design, a marketing team to distribute. One person with one idea could not compete with a company that had five hundred people pointed at the same problem. That bottleneck broke. Peter Steinberger did not beat React because he had a better team. He beat it because he built the exact thing that millions of people had been waiting for, in the moment they were finally ready to receive it, faster than any committee could have approved the roadmap. In my opinion this is the thing most people are still not taking seriously. The question is no longer whether you have the resources. The question is whether you have the idea. What would you build if you stopped waiting to have a team to do it with?

• 
  russell (@russellromney) reported 23 minutes ago

  Github is down, time to do several hours of anti-carpal tunnel hand exercises

• 
  -monseq (@xmonseq) reported 24 minutes ago

  @Surendar__05 Leetcode Streak proves you can ace a pop quiz in a sterile environment. GitHub Streak proves you can accidentally set a server on fire at 3 AM and then valiantly attempt to extinguish it with a `hotfix` branch aptly named 'ohgodwhy.js'. Guess which one demonstrates actual 'can-do' problem-solving?

• 
  GUJJU (@GUJJUIIXI) reported 24 minutes ago

  i built a market intelligence agent with @BNBCHAIN Agent Studio this time, i described what i wanted in Cursor and the agent deployed live with everything already included its own wallet, on-chain identity, and payment rails you're just one command away from setting it up testnet is free to try for a limited time with just a github login what are you building first?

• 
  Sethian (@theSethian) reported 26 minutes ago

  Your AI agent still needs a babysitter. Owain Lewis shows the better version: give it a goal, a clock, and a way to prove the work is done. Old workflow: you write the prompt, read the answer, spot the failure, paste the next instruction, run the test, paste the error back, and keep steering. You are still the engine. His setup uses three primitives: A goal gives the agent a finish line. Deploy the app, wire CI/CD, check the health endpoint, check the web app, and stop only when the app is live. A loop gives it a clock. Every 5 minutes, check the PR, read new feedback, fix what changed, and keep going. A scheduled automation gives it a recurring job. Scan production logs every morning, find errors, reproduce the bug, add tests, and open a PR with evidence. The best examples are the work devs keep putting off: > memory issues hiding in production logs > stale docs drifting away from the code > GitHub issues waiting for labels > old tickets ready but untouched > PR feedback nobody wants to refresh all day > deployments that need a real health check The important part is the verifier. The agent doesn't get to call the work done just because it produced output. Tests, builds, health checks, a separate model, or a human review step have to confirm it. Otherwise you don't have a loop. You have an agent shipping confident garbage on a schedule. The article below breaks down the full anatomy: verification, memory, maker-checker splits, open vs closed loops, cost per accepted result, and the point where the human still needs to step back in.