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 (62%)
• Errors (21%)
• Sign in (18%)

Live Outage Map

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

City	Problem Type	Report Time
Tlalpan	Sign in	2 days ago
Quilmes	Website Down	2 days ago
Bengaluru	Website Down	4 days ago
Yokohama	Sign in	5 days ago
Gustavo Adolfo Madero	Website Down	9 days ago
Nice	Website Down	10 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:

• 
  Emedy (@EmedyXBT) reported 5 minutes ago

  @Bybit_Official @BybitAfrica Local virtual dollar cards made perfect sense when you first discovered them. Naira cards were restricted from processing international transactions, which meant apps like Spotify, Amazon, Adobe, GoDaddy, GitHub, and so many others became unreachable. Local fintech apps launched USD-denominated virtual cards within minutes. The problem looked finished. So we used them, recommended them to friends, and kept using them.

• 
  Tony Junkes (@tonyjunkes) reported 7 minutes ago

  Not having a “to top of page” button on a GitHub PR’s Files Changed tab when going well down a list of changed files is painful. Yes the home key does the thing, but hand on mouse, mouse yearns to click.

• 
  Danilo (@Daniel_adsss) reported 9 minutes ago

  Elon just dropped the entire X algorithm on GitHub and the code tells you exactly how to win the For You feed. Grok scores every post based on predicted engagement. Likes, replies, reposts all push you up. Blocks, mutes and reports drag you down. Which means every sharp comment you leave on a big account is training the algorithm to show more people like you that content. 16.5k stars in 24 hours. Developers already pulling it apart.

• 
  Foy Savas (@foysavas) reported 10 minutes ago

  Does Github actually still use the Unicorn web server? Or have they just kept the error image? I need to know.

• 
  Alef Benson (@AlefBens) reported 10 minutes ago

  @_sirajuddeen_ @OfcMachete19 @iupdate I've been burnt too many times. Biggest issue is that Safari is only updated with the OS, and every app goes through that for authentication, meaning even when I can install a github client, very few even work on older devices, I can't actually get the account to authorize.

• 
  Moe Sbaiti (@MoeSbaiti) reported 11 minutes ago

  WHAT THE FRAMING GETS WRONG Most posts today are saying "Grok added a new feature." That framing is backwards. What happened is that an agent framework with over 110,000 GitHub stars, the number 1 ranking on OpenRouter, and an NVIDIA endorsement just got native access to one of the most capable models available through a simple OAuth login. xAI made the announcement. Not Nous Research. Hermes Agent also self-improves. When it solves a hard problem, it writes a skill file for that solution and saves it. The longer it runs on your specific workflows, the more capable it becomes for your specific context. That is not how people are talking about this today. The memory layer and the self-improvement loop are the actual product. Grok is the engine.

• 
  C. ₿utt 📵 (@ctbutt114) reported 14 minutes ago

  @zquestz Reports are an issue with GG20, which was identified last month and set to be addressed. However, being open source, the bug was revealed via GitHub, & someone took advantage. Single bad actor on a new node. DLKS has been on the roadmap. Needed faster now.

• 
  Arun Srivastava (@arunsrivastava_) reported 14 minutes ago

  It seems there is some issue in GitHub, actions are getting queued and not even getting cancelled @GitHubIndia #github #githubdeployment

• 
  Dave Berkeley 💙😷 (@daveberkeleyuk) reported 16 minutes ago

  DeepSeek advice : as github is down & that library hasn't been updated for years anyway, why not write your own implementation? While you're waiting for github to return. I like the way deepseek talks.

• 
  Louis Gleeson (@aigleeson) reported 17 minutes ago

  Grok runs the X algorithm. I just read the entire open-sourced codebase line by line. Here is exactly what makes a post go viral on X right now (save this): xAI quietly dropped the full For You algorithm on GitHub. 16,500 stars. Apache 2.0. Every Rust file, every Python script, every ranking signal. The first thing you need to understand is that there is no hand-engineered ranking anymore. None. xAI removed every single human-written rule from the system. The README states it directly. A Grok-based transformer does all the ranking now. That changes everything about how you should post. The transformer does not care about your follower count. It does not care about your blue check. It does not care about hashtags. It is looking at one thing. Your post's predicted engagement score across 15 specific actions. Here are the exact 15 actions the model is predicting for every post in your feed right now. Copied directly from the code: P(favorite). P(reply). P(repost). P(quote). P(click). P(profile_click). P(video_view). P(photo_expand). P(share). P(dwell). P(follow_author). P(not_interested). P(block_author). P(mute_author). P(report). The first eleven are positive. They push your post up. The last four are negative. They push it down. Your final score is the weighted sum of all fifteen. That is the formula. That is what every viral post is solving for whether the author knows it or not. Now look closer at the list. Eleven different ways to win. Most creators only optimize for likes and reposts. They are leaving nine signals on the table. The strongest signal in that list is dwell. Time spent on your post. The algorithm tracks how long someone stops scrolling to read what you wrote. A 400-word post that holds someone for 12 seconds beats a one-liner that gets 50 likes. The model has learned that dwell predicts every other engagement. This is why long posts are exploding right now. Not because X "promotes" them. Because they generate dwell, and dwell stacks on top of every other prediction the model is making. The second thing buried in the code that nobody is talking about is candidate sourcing. Your post enters the feed through two pipelines. Thunder serves your post to your followers. Phoenix serves your post to everyone else. Phoenix is the one that makes you go viral. Phoenix is a two-tower model. One tower encodes the user. The other tower encodes every post on the platform. It does similarity search using dot product matching against the global corpus. Then it pushes the top matches into feeds of people who have never followed you. This is exactly how a 12-follower account suddenly hits 800,000 views. Phoenix found a semantic match between the post and a user's engagement history, and the transformer scored it high on its 15 actions. Which means your post is not competing with your followers' posts. It is competing for embedding space. The way you win Phoenix is specificity. The two-tower model rewards posts that sit in a clear semantic neighborhood. Vague posts get vague embeddings and never get retrieved. Sharp posts about a specific topic with specific words get pulled into feeds of people obsessed with that topic. This is why "I built a SaaS" gets nothing and "I built a Postgres-to-Snowflake CDC pipeline in 4 hours using Estuary" goes viral. Same person. Same product. Completely different embedding. The third thing in the code is the Author Diversity Scorer. The model deliberately attenuates repeated author scores in the same feed. Translation: if your last three posts already got served to a user, the fourth post gets a penalty. This kills the "post 8 times a day for the algorithm" strategy. The algorithm is specifically engineered to dampen that. Better to post fewer times with stronger content than to flood and have your own posts compete with each other. The fourth thing is the filter list. Before any post gets scored, it has to pass through ten filters. The MutedKeywordFilter. The PreviouslySeenPostsFilter. The AuthorSocialgraphFilter. Plus a final VFFilter that removes anything classified as deleted, spam, violence, or gore. What kills your reach more than anything else is the PreviouslySeenPostsFilter. If a user has already seen your post once, you are filtered out completely from their feed. Forever. Which means every reply you make to a viral tweet that does not get visibility is permanently dead weight for that user. This is why the people who win at X reply only when their reply itself is good enough to be a standalone post. The last thing, and the one that should change how you write every single post: candidate isolation. During ranking, the transformer cannot let your post attend to other posts in the batch. It only attends to the user's engagement history. Your post is being scored alone. Against itself. Against what the user has previously engaged with. That is the entire game. Stop writing for the timeline. Write for the engagement history of the people you want to reach. Find the topics they already like, the accounts they already follow, the threads they already saved. Write into that semantic space. Phoenix will do the rest. The algorithm is no longer a mystery. It is sitting on GitHub at 16,500 stars. Apache 2.0. Anyone can read it. Almost nobody will. Link in comments.

• 
  Fareesh Vijayarangam (@fareesh) reported 18 minutes ago

  @ThePrimeagen tbh I have zero reliability issues with GitHub I wonder if it's a western hemisphere thing

• 
  Jubilance Pheesh - Adaptives Engineer (@LuftRaptor) reported 21 minutes ago

  @da_asmodai @Pirat_Nation That’s not a 4th option, that’s literally one of the existing options. Publishing server host binaries complies with the law. A single GitHub that’s publicly accessible complies. The executable doesn’t have to be self contained, just have tools up to make the game playable

• 
  Scott Rudy (@scottrudy) reported 21 minutes ago

  @davidfowl I have GitHub Actions for Static Web Apps with .Net azure functions, but they refuse to update for .Net 10. Still stuck on 9 despite open issues.

• 
  ฿Ø₮₴Ø₦Ɇ (@botsone) reported 27 minutes ago

  I just downloaded my entire github and told hermes to extract the file, and upload every repo to my home *** server. It one-shotted it.

• 
  Franz Hemmer (@franzhemmer) reported 29 minutes ago

  @burkeholland @github Anyone else getting this on first session request? Error: Execution failed: Error: 400 "checking third-party user token: bad request: Personal Access Tokens are not supported for this endpoint\n" (Request ID: E599:3D91FF:607E4C:690DC2:6A075036) I had copilot scrutinize that there is no trace of a PAT anywhere and that I'm authenticating correctly with OAuth. No issues in my account setup - all looks green and connected.

• 
  Péter Szilágyi (@peter_szilagyi) reported 32 minutes ago

  @josefprusa @Mojee3d @Prusa3D I have a Prusa, across the parts and kits spent probably over 2K EUR on it. The multi-material printer fails incredibly often, software issues / hangs, random overvoltage errors, ignored github issues, etc. It’s not only about hw price, support is also very lacking, unfortunately.

• 
  Zack Chapple (@Zackary_Chapple) reported 34 minutes ago

  @_bgwoodruff That is fair, I think its less of a GitHub dunk and more of a cry of frustration, had several times trying to do a demo or do something this week and they were fundamentally down. We've had to isolate from GitHub more than we should and thats a scary thing.

• 
  Sum0janedoe (@sum_janedoh) reported 37 minutes ago

  @Denosko1 @OrahOnX Hey Mrs. D. Just read this about the algo going public on github. Maybe it will be helpful for you? Here be the ruuules: :) It punishes for muting blocking etc. Who knew, huh? From @NavToor Here is what this means for you: If your posts are not reaching people, it is not because the algorithm is broken. It is because the algorithm is working exactly as designed. It rewards: 1. Posts that get reactions across multiple action types (a like AND a profile click AND a follow beats five likes alone) 2. Conversation depth (quote tweets are worth more than reposts in the math) 3. Dwell time (write posts people stop to read) 4. Posts that convert viewers into followers (your bio is part of your post) 5. Variety from each author (post less, post better) And it punishes: 1. Mutes 2. Blocks 3. Reports 4. "Not interested" clicks.

• 
  bluehatone (@bluehatone) reported 39 minutes ago

  Give AI real authority over low risk tasks. McKinsey says 60–70% of tasks can be partly automated and AI could add $13T by 2030. Zendesk says 69% will use AI for simple issues. GitHub finds devs finish tasks up to 55% faster. Set guardrails and review.

• 
  Aditya Sharma (@aditya_sharma) reported 40 minutes ago

  elon musk dropped the X algorithm on github. i read all 25,000 lines so you don't have to. here's what actually decides your reach. what actually matters - dwell time is the entire game. how long someone pauses on your post is counted twice in the scoring. likes barely move the needle. the pause does. - saves and shares are the highest-value engagement after dwell. they signal the strongest intent. - video has a minimum duration floor. clips shorter than the threshold get zero video credit. five seconds plus, always. - one post per conversation thread survives in any feed. your five-post thread competes with itself. the algorithm picks the strongest one. - replies to big accounts (1000+ followers) get scored on a 0-3 quality scale. high score and you land in the reply panel of viral tweets. low score and you're invisible. - replies to small accounts get a binary spam check only. no quality scoring path. no reach upside. - mutual follow overlap matters. tight clusters of mutuals create reach corridors for everyone in them. - clear topic identity beats vague posting. the algorithm tags your post with topics. clear topics route you to people who follow those topics. - new accounts on the platform get an easier path to reach you than established ones. if you target young/new users, the algorithm is on your side. what kills your reach - posting too often. the algorithm has decay coded in. your second post of the day gets a fraction of your first. your fifth gets almost nothing. - quoting or replying to a flagged tweet. you inherit the badness. your whole post gets dropped even if it's clean. - ai slop. there's a dedicated slop detector that scores your post 1 to 3. high slop = killed reach. - being unclear what your post is about. vague content doesn't match anyone's interests cleanly. - mid-controversial content. it gets pushed away from the high-attention slots in the feed because ads can't sit next to it. - posting your own tweet's reply hoping it boosts the original. only one of them shows up. it might be the reply, not the original. myths to kill - hashtags do nothing. zero boost in the code. they're not even read by the ranker. - premium doesn't get you reach. paid and free accounts go through the same pipeline. - long threads don't beat single posts. the algorithm picks one post per thread. - engagement bait doesn't work. it trips spam classifiers on low-follower accounts. - posting twelve times a day doesn't get twelve impressions. it gets one strong one and eleven weak ones competing with each other. - replying to viral tweets isn't easy reach. the quality bar is high. cheap replies fall straight into the spam path. - timing tricks don't beat ranking. timing helps you enter the candidate pool. quality decides if you win. - external links don't hurt you. clicks are actually one of the 19 positive scoring signals. - the algorithm doesn't hate any specific format. it hates unclear content. format is fine if the content is sharp. - you don't need 10k followers to get reach. the algorithm doesn't read follower count as a scoring input. it reads engagement quality. the playbook - write posts that make people pause for 5+ seconds. dense info, clear structure, screenshots with detail, comparisons. - if you use video, clear the duration floor. always. pick one clear topic per post. don't mix five things into one tweet. - reply to bigger accounts in your niche with substantive, high-effort replies. one good reply beats ten mediocre ones. - build mutuals in tight clusters around your niche. broad spray-follow strategies don't help. focused clustering does. - post 1-2 times a day, not 10. quality compounds, volume decays. - don't quote tweets that look flagged or risky. clean what you cite. - write like a human. don't post ai output verbatim. target newer users on the platform if you can. they have a friendlier reach path for creators. if you're a small account starting out - replies to big accounts in your niche are your highest-leverage move - build a tight mutual cluster of 50-200 accounts in your exact space - one strong post a day beats five medium ones clear topic identity, every single post if you have an established audience - your reach problem is breaking outside your network - dwell time on individual posts is your biggest unused lever - clean brand safety keeps you in prime feed slots next to ads - volume hurts you more as you grow, not less the whole system is built on one bet: that a model fed engagement data can decide relevance better than any rule. there's no hashtag boost, no follower boost, no time-of-day trick in the code. just sequences in, probabilities out. what works is what humans actually want to read. the algorithm is just better at measuring it now.

• 
  Alex Derocq (@akaasten) reported 40 minutes ago

  @steipete Crazy how the GitHub "@codex review this" feature is way better than the local review. It spots more issues like 90% of the time.

• 
  Lucy (@TheLucyShow1) reported 41 minutes ago

  FYI: GitHub is a platform where people store, manage, and collaborate on code and software projects. It’s built around a system called ***, which tracks changes to files over time. Think of it like: Google Docs for programmers — multiple people can work on the same project together. A backup system — every version of the code is saved. A portfolio site — developers show off projects there. A collaboration hub — companies and open-source communities build software together. Here are the core ideas: Repositories (“Repos”) A repo is basically a project folder stored on GitHub. It can contain: Code Images Documentation Websites Apps Games Example: A developer making a weather app would keep all the app files in one repo. *** *** is the version-control system underneath GitHub. It tracks: who changed something what changed when it changed how to undo mistakes So if someone breaks the code, you can roll back to an earlier version. Commits A commit is like a saved checkpoint. Example: “Added login screen” “Fixed typo” “Updated homepage colors” Each commit creates a history trail. Branches Branches let people experiment without breaking the main project. Example: Main branch = stable version New branch = testing a new feature If it works, the changes get merged in. Pull Requests A pull request is basically: “Hey, I made changes — can you review and approve them?” Teams use these to discuss and review code before adding it to the main project. Open Source GitHub is huge for open-source software. That means anyone can: view the code contribute improvements report bugs learn from real projects Projects like: Linux Foundation’s Linux ecosystem Mozilla Firefox Microsoft VS Code all use GitHub heavily. Why People Use It Software development Team collaboration Backup/version history Learning programming Sharing projects publicly Building websites/apps Managing documentation Simple Analogy Imagine writing a book with friends: GitHub stores the book *** tracks every edit Branches let you try alternate chapters Pull requests ask others to review changes Commits are saved drafts That’s essentially how software teams build programs together.

• 
  Salt (@XMonetizationC_) reported 41 minutes ago

  🔥 Linus Torvalds has just made it clear that Linux will not become a dumping ground for AI-generated code. After months of internal debate, the Linux community has published its official rules on the use of tools like GitHub Copilot. The verdict: You can use AI to program, but the “slop”—that low-quality code spat out without thinking—does not pass the filter. The phrase that sums it all up: “Humans assume the errors.” You can rely on Copilot, Claude, or whatever you want. But if that code makes it into the Linux kernel, you are responsible. You verify it. You fix the bugs. You guarantee it meets the standards. This is the most mature stance I’ve seen in the open-source ecosystem regarding AI: neither hysteria nor blind adoption—just clear responsibility. The kernel has 30 years of history. They’re not going to ruin it to save 20 minutes with an autocomplete.

• 
  青川一 (@worigoule) reported 44 minutes ago

  @ZooL_Smith And then you google solutions and found yourself ended up in a github merge request or more likely a issue page written in like, 2 years ago

• 
  Peter Steinberger 🦞 (@steipete) reported 47 minutes ago

  @EndGovTyranny Please file a github issue with more infos - with that alone we can't help. That's likely a weird model edge case. If you want a fast fix, use one of the top-gen models (OAI, Anthropic)

• 
  nadya (@sosidudku) reported 48 minutes ago

  We decided to benchmark Hermes Agent vs OpenClaw on a real task. ran both on local Qwen 3.6 35B. task: scrape GitHub star history for both tools, find what caused the growth spikes, build a live dashboard in the browser. OpenClaw: 203k tokens, 12m 01s — wrote a bash script Hermes: 257k tokens, 33m 01s — wrote a SKILL.md OpenClaw: hit GitHub API, got truncated responses, paginated through contributors, pulled star-history JSON, found a security incident in OpenClaw's history, fetched SVGs, fixed broken HTML from trimming, rewrote it clean. Hermes: parallel tool calls across GitHub API, web search, and browser. Hit Google rate limit, auto-switched to DuckDuckGo. Fetched article contents, mapped viral moments, then built the dashboard. Both shipped a live dashboard with star growth charts and spike annotations.

• 
  Jeff Hayes (@JD__Hayes) reported 49 minutes ago

  @FredKSchott I'm interested, but web page is down and could not find on github.

• 
  NEET INTEL (@neetintel) reported 52 minutes ago

  A post "decoding" X's new algorithm has gone viral. It tells you what's dead, what wins, and to screenshot it. X open-sourced the entire algorithm on GitHub, so I downloaded it and checked the claims against the real code. Most of it doesn't hold up. What the post got WRONG: → "Small accounts get a 3x boost from out-of-network reach." It's the opposite. One part of the code (a file called oon_scorer) exists purely to turn DOWN posts from people you don't follow. Its own comment says "prioritize in-network." The thread printed the algorithm backwards. → "Media gets 2x the weight." There's no 2x. The code just records whether a post has an image. It's a plain yes/no without any multiplier attached. → "Posting 4+ times a day triggers a penalty." There's a real rule that stops one person flooding your feed. But here's the deal: it only spaces out how often you show up in a single scroll. There's no daily count, and no number 4. That was invented. → "Closers like 'what do you think?' get you flagged." There is no engagement-bait detector anywhere in the code. → "Long 4,000-character posts get boosted." I searched the whole codebase for "4000." Nothing. What it got RIGHT (one thing): → Replies really are judged by WHO replies, not just how many. The code has a setting for whether a large account joined your thread. Credit where due. The irony? The repo ships a file that scores post quality. One thing it measures is literally called a "slop score" — X built a tool to detect low-effort filler. A recycled "what's dead / what wins" thread is exactly that. The takeaway? X's algorithm is public. Anyone can open it, but almost nobody does. Instead, they reshare a thread that summarized a blog that paraphrased a tweet. When a post hits you with confident numbers, ask the one question that matters: did they actually open the file?

• 
  RYMAR (@rymaaaar) reported 55 minutes ago

  A 10-year-old kid built a trading bot that pulls $4,200/month on autopilot He's 10. He doesn't play Roblox like other kids. He sits in front of three monitors and writes Python for 6 hours a day. And he's making real money from it. He started watching coding tutorials on YouTube when he was 6. By 7 he was solving LeetCode Mediums. By 8 he had his first paying client on Fiverr - the guy had no idea he was paying a kid. In the video he's debugging an algorithmic trading bot. Real risk management. Real position sizing. Stuff most CS grads can't write. His parents say he's already pulled in $47,200 from freelance gigs and his own SaaS subscriptions. He doesn't watch cartoons. He reads GitHub issues. While other kids his age are learning long division, he's running an automated income stream from his bedroom. His goal by 12 is to hit $10k MRR and retire his parents.

• 
  /home/bill (@Bill_Xiong) reported 58 minutes ago

  Github actions down again. @github, what is going on? I sure hope this isn't the start of the MSFT acquisition > Generationally fumble the bag pipeline that already happened with skype.