Stop Killing Games

Stop Killing Games Sun, 31 May 2026 The "Stop Killing Games" movement is making progress with the advancement of California AB 1921, a bill designed to stop developers from permanently bricking games when they shut down their servers. If you're a gamer who has watched a $70 purchase turn into a useless desktop icon overnight, you're entirely justified in your outrage. Having a software developer reach into your home and break your own software is a profound violation of trust. But as the movement gains momentum, it's becoming clear that they're aiming at the wrong target. Right now, advocates are treating game preservation purely as a consumer rights issue. They're lobbying for laws that force developers to build offline modes, issue final server patches, or offer refunds. This is fundamentally treating a symptom while ignoring the disease. The real problem isn't that developers are "killing games" - it's that they have the unquestioned, systemic power to do so in the first place. What gamers are actually experiencing is the inherent injustice of proprietary software. It's a system built from the ground up to mistreat users by denying them control over their own computers. Without using the exact vocabulary, the gaming community is spontaneously waking up to the exact ethical arguments the Free Software Foundation has been making for forty years. Gamers are currently saying, "You shouldn't be able to control how and when I run this code." They don't just want a band-aid; they're intuitively demanding software freedom. They just haven't realized it yet. The Anatomy of a Kill Switch When a game "dies" because a publisher unplugs the server, it isn't experiencing a natural death - it's an execution. But how is it possible for a company to reach across the internet and execute a piece of software living on your hard drive? It's only possible because the software is proprietary. Decades ago, Richard Stallman and the Free Software Foundation established a fundamental rule of modern computing: If the user doesn't control the program, the program controls the user. And when a program controls the user, the developer holds absolute power over both. With proprietary software, the developer holds all the keys. They don't share the source code, they lock down the server architecture, and enforce compliance through Digital Restrictions Management (DRM). Even games which are normally played locally can require a constant connection to the server and refuse to run otherwise. These mechanisms aren't merely technical necessities; they're digital handcuffs. They're designed specifically to prevent you from studying how the game works, changing it so that it's not dependent on a server for authorization to run locally, or modifying the client to connect to a different, community-run server to keep the world alive. The "Stop Killing Games" movement views server shutdowns as an unfortunate business practice that should be regulated. But through the lens of software freedom, we can see the deeper truth: the ability to flip a switch and turn your $70 game into a digital paperweight isn't an accidental oversight or an unavoidable side effect of modern networking. It's the intended design. Proprietary software is built to assert dominance over your machine. Its very nature is designed to deny you the fundamental right to run the software as you see fit, for as long as you see fit. The mistreatment you feel when a game is taken from you is baked into the code itself. The kill switch isn't a bug in the proprietary software model - it's the ultimate expression of it. Gamers Already Understand Free Software Ethics The most tragic part of the disconnect between the gaming community and the Free Software movement is that they're fighting the same battle. Gamers are already articulating the core ethics of software freedom - they just aren't using the academic terminology of licenses and source code repositories. Listen to the shared outrage driving the "Stop Killing Games" campaign: "I have this software. It's sitting on my hard drive. You shouldn't have the legal or technical ability to reach into my computer, break my software, and walk away." This is the exact warning Richard Stallman and the Free Software Foundation have been shouting from the rooftops since the 1980s. Gamers are experiencing, on a mass scale, exactly how proprietary software is actively used to mistreat people. They're realizing that when the source code is hidden and legally restricted, they're entirely at the mercy of someone else. The public has already grasped this concept in the physical world through the Right to Repair movement. When John Deere used proprietary software to lock farmers out of repairing their own tractors, or when Apple deliberately made it impossible to replace a cracked iPhone screen without specialized authorization, the public recognized it immediately as an extortionate scam. They understood that if you're legally or technically barred from opening the hood to fix the engine, you don't actually own the vehicle. You're just renting it. Free software is simply the digital manifestation of the Right to Repair. Gamers are currently looking at their dead, unplayable games and experiencing that same realization. They're learning the hard way that if they can't access the server code, or if it is illegal to modify the game client to point to a fan-run server, they never truly owned the game at all. They merely bought temporary permission to play it until the developer decided it was time to move on. By demanding the right to keep their games alive, gamers are demanding the right to open the digital hood. They are 90% of the way to understanding that software freedom isn't a fringe, hacker ideology - it's a baseline requirement for being in control of what your computer does. The True Demand: The Four Freedoms in Gaming The "Stop Killing Games" movement doesn't need to invent a new bill of rights. The exact framework required to protect themselves permanently already exists, and it's been battle-tested for decades: The "Four Essential Freedoms" that define whether a user truly controls their software.

      Freedom 0: The freedom to run the program as you wish,
      for any purpose. In gaming, this means the right to boot up
      the game you purchased. It means no mandatory online
      "handshakes" for single-player campaigns, no required
      third-party launchers acting as gatekeepers, and the
      ability to play your game even if the publisher goes
      completely bankrupt tomorrow.
      Freedom 1: The freedom to study how the program works,
      and change it so it does your computing as you wish. This
      is the anti-kill switch. When a developer shuts down
      official servers, Freedom 1 guarantees your right to open
      up the hood, study the game's source code, and modify it so
      that it points to your own custom server instead of a dead
      one.
      Freedom 2: The freedom to redistribute copies so you
      can help others. A multiplayer game cannot survive if only
      one person has the server files. Freedom 2 ensures that the
      community has the legal right to share the server software,
      guaranteeing that fans can always host a match, run an MMO
      shard, or organize a tournament without fear of a DMCA
      takedown.
      Freedom 3: The freedom to distribute copies of your
      modified versions to others. This is the foundation of the
      modding community and fan restorations. It guarantees your
      right to share community patches, server emulators, and bug
      fixes that keep abandoned games functional on modern
      hardware.
    
    Look closely at those four freedoms. If a game comes with
    those, it literally can't be killed.
    The developer loses the power to destroy the game, meaning
    the government never has to step in to force an "end-of-life"
    patch. The preservation of the game is guaranteed by the
    community's control over the code. AB 1921 tries to regulate
    the symptoms of proprietary control, but refuses to address
    the control itself. To borrow a metaphor, they politely ask
    the master to stop hitting the user, rather than taking away
    the whip. The users deserve better; they deserve software
    freedom. What the "Stop Killing Games" movement actually
    wants is software freedom - they just need to realize that
    the only way to achieve it is to demand it by its true name,
    and not settle for something less.