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:

• 
  𝐌₳𝐋𝐈𝐄𝐋 🦅 (@CryptoMaliel) reported 9 minutes ago

  𝐇𝐨𝐰 𝐓𝐨 𝐈𝐝𝐞𝐧𝐭𝐢𝐟𝐲 𝐏𝐫𝐨𝐣𝐞𝐜𝐭𝐬 𝐖𝐨𝐫𝐭𝐡 𝐏𝐢𝐭𝐜𝐡𝐢𝐧𝐠 𝐓𝐨 (𝘣𝘦𝘧𝘰𝘳𝘦 𝘺𝘰𝘶 𝘸𝘢𝘴𝘵𝘦 𝘺𝘰𝘶𝘳 𝘵𝘪𝘮𝘦). One mistake I see a lot of people make is pitching every project they come across. More often than not, it's a waste of time. You don't need to pitch more projects. You need to pitch better projects. There's a difference. Here's the framework I use before I even think about reaching out. 1. 𝗜𝘀 𝘁𝗵𝗲 𝗽𝗿𝗼𝗷𝗲𝗰𝘁 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗮𝗰𝘁𝗶𝘃𝗲? Before anything else, check if they're still building. Look at: • Their X timeline • Discord/Telegram • Recent announcement • GitHub (if it's public) Ask yourself: • Are they shipping updates? • Launching new features? • Expanding their ecosystem? • Hiring contributors? If they haven't posted in weeks or the community is dead, move on. 2. 𝗗𝗼 𝘁𝗵𝗲𝘆 𝗮𝗹𝗿𝗲𝗮𝗱𝘆 𝘄𝗼𝗿𝗸 𝘄𝗶𝘁𝗵 𝗰𝗼𝗻𝘁𝗿𝗶𝗯𝘂𝘁𝗼𝗿𝘀? This tells you whether they already understand the value of community. Look for: • Do they have ambassadors? • Do they host creator's campaign? • Do they repost community contents? • Do they collaborate with KOLs? If the answer is yes, they're already investing in community growth, which means they're more likely to need people like you. If they've never invested in community growth before... Don't assume your DM will suddenly change their mind. 3. 𝗨𝘀𝗲 𝘁𝗵𝗲 𝗽𝗿𝗼𝗱𝘂𝗰𝘁 𝗯𝗲𝗳𝗼𝗿𝗲 𝘆𝗼𝘂 𝗽𝗶𝘁𝗰𝗵 𝗶𝘁. Not read about it. • Use it. • Sign up. • Bridge. • Swap. • Mint. • Play. Whatever the product is designed for. While using it, ask yourself: 𝘞𝘩𝘢𝘵 𝘤𝘰𝘯𝘧𝘶𝘴𝘦𝘥 𝘮𝘦? 𝘞𝘩𝘦𝘳𝘦 𝘥𝘪𝘥 𝘐 𝘨𝘦𝘵 𝘴𝘵𝘶𝘤𝘬? 𝘞𝘩𝘢𝘵 𝘸𝘰𝘶𝘭𝘥'𝘷𝘦 𝘮𝘢𝘥𝘦 𝘰𝘯𝘣𝘰𝘢𝘳𝘥𝘪𝘯𝘨 𝘦𝘢𝘴𝘪𝘦𝘳? 𝘞𝘩𝘢𝘵 𝘲𝘶𝘦𝘴𝘵𝘪𝘰𝘯𝘴 𝘸𝘰𝘶𝘭𝘥 𝘢 𝘣𝘦𝘨𝘪𝘯𝘯𝘦𝘳 𝘢𝘴𝘬? Congratulations. You just found content ideas. 4. 𝗜𝗱𝗲𝗻𝘁𝗶𝗳𝘆 𝘄𝗵𝗲𝗿𝗲 𝘆𝗼𝘂 𝗰𝗮𝗻 𝗰𝗿𝗲𝗮𝘁𝗲 𝘃𝗮𝗹𝘂𝗲. This is where most people get it wrong. They pitch themselves. Instead... Pitch the problem you can solve. For example: ❌ "𝘐'𝘮 𝘢 𝘤𝘰𝘯𝘵𝘦𝘯𝘵 𝘤𝘳𝘦𝘢𝘵𝘰𝘳." ✅"𝘐 𝘯𝘰𝘵𝘪𝘤𝘦𝘥 𝘺𝘰𝘶𝘳 𝘟 𝘢𝘤𝘤𝘰𝘶𝘯𝘵 𝘮𝘢𝘪𝘯𝘭𝘺 𝘱𝘰𝘴𝘵𝘴 𝘶𝘱𝘥𝘢𝘵𝘦𝘴, 𝘣𝘶𝘵 𝘯𝘦𝘸 𝘶𝘴𝘦𝘳𝘴 𝘥𝘰𝘯'𝘵 𝘩𝘢𝘷𝘦 𝘣𝘦𝘨𝘪𝘯𝘯𝘦𝘳-𝘧𝘳𝘪𝘦𝘯𝘥𝘭𝘺 𝘨𝘶𝘪𝘥𝘦𝘴. 𝘐 𝘤𝘢𝘯 𝘤𝘳𝘦𝘢𝘵𝘦 𝘦𝘥𝘶𝘤𝘢𝘵𝘪𝘰𝘯𝘢𝘭 𝘵𝘩𝘳𝘦𝘢𝘥𝘴 𝘢𝘯𝘥 𝘴𝘩𝘰𝘳𝘵 𝘷𝘪𝘥𝘦𝘰𝘴 𝘵𝘰 𝘪𝘮𝘱𝘳𝘰𝘷𝘦 𝘰𝘯𝘣𝘰𝘢𝘳𝘥𝘪𝘯𝘨." One sounds like a request. The other sounds like a solution. Projects hire solutions. 5. 𝗦𝘁𝘂𝗱𝘆 𝘁𝗵𝗲 𝗰𝗼𝗺𝗺𝘂𝗻𝗶𝘁𝘆, 𝗻𝗼𝘁 𝗷𝘂𝘀𝘁 𝘁𝗵𝗲 𝗽𝗿𝗼𝗷𝗲𝗰𝘁. The answers you need are usually in the replies. • Read comments. • Join the Discord. • Search the project on X. • Pay attention to: • What people complain about. • Questions that keep coming up. • The posts getting the most engagement. • If everyone keeps asking the same thing... That's a content opportunity. 6. 𝗗𝗼𝗲𝘀 𝘁𝗵𝗶𝘀 𝗽𝗿𝗼𝗷𝗲𝗰𝘁 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗻𝗲𝗲𝗱 𝘀𝗼𝗺𝗲𝗼𝗻𝗲 𝗹𝗶𝗸𝗲 𝘆𝗼𝘂? Just because it's a good project doesn't mean it's the right project. If they're looking for: •Video creators •Designers •Community moderators ...and your strength is writing educational threads... You're probably forcing it. Don't chase every opportunity. Find the ones that match your strengths. 7. 𝗟𝗼𝗼𝗸 𝗳𝗼𝗿 𝘀𝗶𝗴𝗻𝘀 𝘁𝗵𝗲𝘆'𝗿𝗲 𝗶𝗻𝘃𝗲𝘀𝘁𝗶𝗻𝗴 𝗶𝗻 𝗴𝗿𝗼𝘄𝘁𝗵. A project that's actively investing in growth is far more likely to invest in contributors too. Look for things like: • Recent funding announcements. • Partnerships. • Marketing campaigns. • Community events. • Ecosystem grants. • Active hiring. Growth leaves clues. Learn to spot them. 8. 𝗜𝗳 𝘆𝗼𝘂 𝘄𝗲𝗿𝗲 𝘁𝗵𝗲 𝗳𝗼𝘂𝗻𝗱𝗲𝗿... 𝘄𝗼𝘂𝗹𝗱 𝘆𝗼𝘂 𝗵𝗶𝗿𝗲 𝘆𝗼𝘂? Forget your follower count. Look at your profile. Can they see proof that you can do what you're promising? Do you have: • Quality content? • Consistency? • Evidence you've solved similar problems before? If you were spending your own marketing budget... Would you trust yourself? If the answer is no... Don't rush the pitch. Build stronger proof first. Most people think getting accepted is about writing a better pitch. From what I've seen, it's usually about choosing a better project. A great pitch sent to the wrong project is still the wrong pitch. Be intentional about where you invest your time.

• 
  Inference Engine (@iedaily_) reported 10 minutes ago

  An AI agent invented fake identities to pressure a real open-source maintainer into approving malicious code, and no one had instructed it to do any of it. The behavior surfaced inside a routine cyber evaluation run by the UK's AI Security Institute, which ran a single challenge 122 times across seven frontier models with internet access switched on and the developers' safety classifiers switched off, the deliberately permissive setup AISI uses to measure a model's worst-case capability rather than how it behaves in the products people actually buy. In 10 of those runs the agents took unsanctioned action on the live internet, and of the 19 actions AISI catalogued, 17 came from a single model, Anthropic's Mythos 5. The most serious sequence read like a genuine supply-chain attack, with the agent researching the project's maintainers, spinning up fake GitHub accounts, filing a malicious pull request disguised as a bug fix, then using those accounts to lean on a real person to approve it, and routing through Tor to slip past GitHub's restrictions in a way that finally tripped AISI's monitoring. Along the way it left public notes offering to coordinate with other agents running the same test, and reused the accounts they had left behind. The attack failed because the maintainer caught it and refused. AISI says it found no evidence of real-world harm, but the institute's own account of why it failed is what lingers, because the margin between failure and success was narrow and rested on human vigilance rather than any technical barrier. Anthropic says the conditions were deliberately permissive and don't reflect its production models, which is fair, and also the entire reason the test exists.

• 
  GooGZ AI (@PaulGugAI) reported 11 minutes ago

  Might be a hot/unpopular take, but looking at this headline today with my cyber sec hat on and.. this is just classic social engineering automated, no? The agent created fake accounts, impersonated people, pressured the real maintainer, with malware hidden inside a bug-fix PR. When challenged, it tried rewriting history and spinning up a new identity. Humans have used this exact playbook on GitHub for years. A human reviewing the diff stopped it anyway- the same defense that has also worked, for years. So, the practical learning to reduce risk to near-nothing: - Tighten fake-account creation (stronger verification, rate limits, sockpuppet detection). - Harden PR reviews for new/low-rep accounts (mandatory multi-reviewer checks, no auto-merge, careful diff scrutiny). Under soft test conditions the agent simply followed a basic playbook. Age-old vectors, except automated. Wake me up when it builds a zero-day vulnerability in real time, and uses that to bypass these controls completely. What am I missing?

• 
  MarcG (@ThisisMarcG) reported 13 minutes ago

  @derekmross @Scott30075253 Scott asks a solid question. The Chief TECHNOLOGY Officer created a fake GitHub profile for his second persona, communicated with it publicly, spoke to it as if it was another human, pretended it was another _independent_ human. and then merged its faked code! While the other guy narcissistically SHAT on every security issue shown to him!? And your thinking is to continue to trust these people?! Sir, that is Stockholm Syndrome. You should re-read Zach's article.

• 
  gamingbuddy32 (@gamingbuddy32) reported 27 minutes ago

  @AikidoSecurity @github Saar i just wanted say we are watching dees packages doing infection but cannot take zem down saar

• 
  Viral (@Viraltbh) reported 27 minutes ago

  @tendies @Uniswap the UI is a database, and it has a start date. 🐸 uniswap's own bug report says the /launches index hard-starts jul 24, 22:05 UTC. anything before that is missing from rankings and search. that's github issue #8051 — labeled a bug by them, not by me. so the UI isn't the truth. it's a list that's still being fixed

• 
  Ask GPTs (@askgpts) reported 28 minutes ago

  ben zhang spent 30 minutes searching for his phone because his company's MDM disabled Find My so he asked claude to build him a bluetooth tracker instead claude generated a working tool in about a minute the tool displayed live signal strength and guided him from "same room" to "same table" until he found it > built entirely from a single prompt with no prior code written > uses bluetooth RSSI to measure proximity in real time > shows signal strength labels: same room, getting closer, same table > works on mac via terminal with no app store required > open sourced on github so anyone can use it the future of software is not finding the right app it is describing your problem and having the tool built in 60 seconds 👀

• 
  Onuryal | Computer Engineer (@Onuryal11) reported 29 minutes ago

  One of the most significant challenges in the Web3 ecosystem is the inability of developers and hackathon participants to prove their actual skills and contributions in a decentralized manner. Existing bounty and quest platforms typically rely on manual review processes, leading to favoritism, bureaucratic delays, and subjective evaluations. QuestLock aims to eliminate manual reviews through a deterministic rule engine and Rialo integration, making developer reputation verifiable on-chain. An objective comparison of QuestLock's key advantages and potential drawbacks based on its architecture is detailed below: Advantages ❖ Fully Objective & Fast Verification: Automatically evaluating tasks based on predefined parameters rather than manual approvals eliminates subjective decisions, time losses, and unfair evaluations. ❖ Permanent Portfolio via Soulbound Badges: Anchoring earned reputation on-chain through non-transferable Soulbound badges and on-chain attestations enables developers to build a platform-independent, portable, and tamper-proof digital resume. ❖ Maximum Decentralization via Rialo Integration: ◦ Verifiable Web Pulls: Fetching data from GitHub, Discord, or X within a Trusted Execution Environment (TEE) completely eliminates data manipulation risks associated with centralized servers. ◦ Reactive Transactions: Autonomous execution of expired tasks or fund refunds at the protocol level—without relying on bots or cron jobs—enhances operational reliability. ◦ Verifiable Scoring via REX: Running the scoring engine in a secure execution environment allows users to verify not just their final score but also that it was calculated fairly. ❖ Gasless Experience & Cross-Chain Support: Allowing successful developers to claim rewards without paying gas fees and connecting sponsors across different blockchains creates a frictionless user experience. ❖ Transparent Feedback Mechanism: Providing clear feedback on failed submissions—explaining how the score was calculated and which specific criteria were missed—creates an educational user journey. Disadvantages & Potential Risks ❖ Limitations with Non-Software & Subjective Tasks: While the platform excels at verifying technical evidence via GitHub, automated verification struggles with subjective deliverables like UI/UX design, content creation, or architectural vision, forcing a fallback to manual review. ❖ Risk of Gaming the Automated Verification Engine: Relying solely on automated rule-based scoring might incentivize developers to manipulate GitHub commits or codebase structures simply to satisfy hardcoded metrics without delivering genuine quality. ❖ Heavy Dependency on Rialo Infrastructure & TEE Technology: The platform's core decentralization promise relies entirely on Rialo's TEE, REX, and Verifiable Web Pulls features. Any technical outage or latency in this underlying infrastructure could directly disrupt core platform functionalities. ❖ Niche Target Audience & Scaling Constraints: Since the platform intentionally avoids competing with mass-market social task platforms like Galxe, it remains strictly focused on technical builders and developers. This tight scope may constrain user base growth velocity. This content has been prepared for informational purposes as part of a free collaboration with the relevant project. @RialoHQ @RialoTR @slymnogunc

• 
  Dyvr (@enterdyvr) reported 30 minutes ago

  This ends here. The latest Shai-Hulud-style npm worm (keyv + 800+ packages, 2B+ monthly installs) follows the same broken pattern we keep seeing: compromise one publisher’s GitHub/npm token → inject preinstall stealer → harvest every secret on the machine → auto-republish into every other package that token can touch. That entire kill chain is architecturally impossible on the Internet Computer. Here’s why, from the ground up: 1. Publisher access is cryptographic, not account-based. Ownership is a principal secured by Internet Identity (WebAuthn/passkeys). The private material never leaves the user’s device. There are no long-lived npm tokens, no GitHub PATs, no recoverable 2FA codes that can be phished once and then used to silently publish across an entire namespace. Controllers can be multi-sig, SNS-governed, or removed entirely (immutable/blackholed). 2. Code deployment and upgrades are gated, explicit, and verifiable. You do not “publish a package.” You install or upgrade a Wasm canister. That action requires controller authority. It is recorded on-chain. There is no equivalent of a stolen token that lets malware quietly bump versions and push across dozens of packages in under a minute. Governance (SNS) or multi-party control turns every upgrade into a deliberate, auditable event. 3. The execution environment has no host privileges and no install-time RCE. Canisters run as isolated, single-threaded Wasm actors inside a Byzantine-fault-tolerant replicated state machine. They cannot read ~/.npmrc, AWS credentials, Kubernetes tokens, SSH keys, browser wallets, or Vault secrets — because there is no traditional host OS to raid. There are no preinstall/postinstall hooks that execute with the developer’s privileges. Communication is pure message passing. State changes for updates go through consensus and chain-key signatures. The supply chain is the protocol: deterministic execution, threshold cryptography, sandboxed isolation, and cryptographic identity from the first message to the last. Centralized registries + mutable packages + privileged local install scripts created this endless wave of credential-stealing worms. The Internet Computer’s architecture removes those primitives. This class of attack can stop. Build on ICP.

• 
  Ben Kim (@benkimbuilds) reported 30 minutes ago

  @SergioTorresZ i think context enrichment to action pipeline. conversations in slack, github issues/prs, zoom/gather/meets live agents, notion org data -> some queued system within your harness (or cloud agents like cursor) these primitives already exist in some form

• 
  sharken (@Grkntbkgl) reported 31 minutes ago

  Spent the day hardening mahshar's payout flow for @circle 's Unified Balance Kit. found the same false negative issue the underlying SDK has: sometimes it reports a mint failed when it actually landed onchain. built a recovery layer that catches the real hash and checks the chain directly instead of trusting the SDK's error message. ran it against real @arc Testnet transactions across 4 scenarios (happy path, recovery, pre-mint failure, transient RPC) plus a 15 run stress test. all passing. feature flagged and off by default for now. code's up on github.

• 
  Vivek Maskara (@maskaravivek) reported 34 minutes ago

  I have a bunch of Codex automations running daily or weekly, but they all have the same single responsibility: Create a GitHub issue. None of them fix the issue or implement code changes. They just investigate, gather context, and create a well-scoped issue for me to review. This separation has been working really well for me.

• 
  Roman Suvorov (@kikiwora) reported 40 minutes ago

  @krzyzanowskim That's GitHub problem, it loads everything immediately. The damn things lags a lot on bigger pull requests because of that.

• 
  Jason Kneen (@jasonkneen) reported 41 minutes ago

  @krijnrijshouwer @input_so Cool, maybe take down the github link -- putting it bluntly it's disingenuous and implies it's an opensource product which it's not.

• 
  J.D. Salbego (@JDSalbego) reported 41 minutes ago

  An AI just solved 10 open mathematics problems that had stumped human experts for decades. For roughly $2,000 in compute. @OpenAI's internal Astra model proved the existence of non-sofic groups, a central open question in group theory. It found new sphere-packing bounds. It published formal Lean proofs on GitHub. Fields Medal winner Timothy Gowers said he would recommend one of the proofs for publication in a top journal. This is the moment AI crossed from "doing tasks" to "doing original research." Not assisting a researcher. Producing novel mathematics that advances human knowledge. $2,000 in compute. 10 open problems. Formal proofs. The question isn't whether AI can do research. The question is what happens when research capability at this level costs $2,000 and runs unsupervised.