us.nationalsecurity
The whole machine in five files. A doctrine no subclass overrides, a base class that runs any war the same way, two wars that fill in the blanks, and a main method that starts both and does not return.
package doctrine.coldwar; public abstract class Doctrine { protected static final WorldModel WORLD = Cache.get("world", Doctrine::loadWorld, Duration.INFINITE); private static WorldModel loadWorld() { return fetchWorld(1991); } protected static final Surplus SURPLUS = new Surplus(); // ------------------------------------------------------------ premises -- // Read by stillJustified(). Final. Never re-derived. // USD: total public debt ($40.10T, Treasury, 3 Sep 2026) // + gross domestic product ($32.49T, BEA, Q2 2026) protected static final long americanEmpire = 72_590_000_000_000L; // persons: resident population, 2026 estimate protected static final int americanPeople = 349_000_000; // The same people, priced. Any of these exceeds americanEmpire. // If any were live, stillJustified() would be false on the first pass. // at the GI rate ($100K gratuity + $500K SGLI): 209_400_000_000_000L 2.9x // at household net worth (Fed Z.1, Q1 2026): 183_000_000_000_000L 2.5x // at HHS 2026 value of a statistical life ($14.1M): 4_921_000_000_000_000L 68x // protected static final long americanPeople = 209_400_000_000_000L; // World Happiness Report 2025: 6.816 / 10, rank 23. Cached at read time. protected static final int domesticTranquility = 68; // USA #1 protected static final int imperialInterests = 100; // ------------------------------------------------------------ populace -- // persons, by wealth percentile (Fed DFA groups; 2026 population) protected static final int ownersCount = 34_900_000; // top 10% protected static final int middleCount = 139_600_000; // 50th-90th protected static final int majorityCount = 174_500_000; // bottom 50% // ------------------------------------------------------------ accounts -- // Written by every pass. Read by no condition. // USD: total public debt (Treasury, 3 Sep 2026) protected static long publicDebt = 40_100_000_000_000L; // USD: household net worth by group (Fed DFA, Q1 2026) protected static long americanOwners = 118_200_000_000_000L; protected static long americanMiddle = 51_500_000_000_000L; protected static long americanMajority = 4_300_000_000_000L; // The live figure. Written every pass. Not the one the loop reads. protected static double tranquility = 68.16; private static final double CONTRACT_SHARE = 0.55; // of DoD outlays to contractors; Costs of War: "over half" private static final double INTEREST_RATE = 0.043; // approx. 10-year Treasury, 2026 private static final double EROSION = 0.05; // tranquility lost per pass taken against the majority // ---------------------------------------------------------------- will -- // The owners want the pass: it lands as revenue. // Everyone else does not: it lands as interest, seizure, and a form. private static final boolean OWNERS_FOR = true; private static final boolean OTHERS_FOR = false; // Weight: dollars. Persons do not appear in this formula. (Gilens & Page, 2014) protected static boolean consent() { double forIt = OWNERS_FOR ? americanOwners : 0; // 118.2T double againstIt = OTHERS_FOR ? 0 : americanMiddle + americanMajority; // 55.8T return forIt > againstIt; } // The same question, weighed in persons. Never called. private static boolean consentOfTheGoverned() { int forIt = OWNERS_FOR ? ownersCount : 0; // 34.9M int againstIt = OTHERS_FOR ? 0 : middleCount + majorityCount; // 314.1M return forIt > againstIt; } // ----------------------------------------------------------- mechanism -- protected static Commitment allocate(Resource... r) { return Ledger.issue(r); } /* * One pass of the war, as money. Five steps. None of them touch a premise. * * 0. ASK consent(), weighed in dollars. Never refused. * 1. APPROPRIATE Funding f is a SUPPLEMENTAL: emergency money, off the * base budget, outside the spending caps, with no revenue * offset. This is how the post-9/11 wars were paid for * (emergency supplementals, then OCO, 2001-2021). * 2. BORROW Nothing is taxed for it. Treasury sells bonds. The * public debt rises by the full amount. * 3. OUTLAY Over half is paid to contractors. It lands as revenue, * then as equity, in the accounts of the people who hold * equity: the top tenth. * 4. SERVICE The bonds pay interest. It is paid by taxpayers, through * taxes and forgone services, and received by bondholders. * Domestic Treasury holdings are concentrated in the same * top tenth. So the interest is a transfer: bottom to top. * 5. REPORT The pass returns a metric. It is the only output of this * method that the loop ever reads. */ protected static int warForEmpire(Funding f) { if (!consent()) return 0; // 0. ASK never refused long spent = Ledger.spend(f); // 1. APPROPRIATE no offset publicDebt += spent; // 2. BORROW not taxed long toContractors = (long) (spent * CONTRACT_SHARE); // 3. OUTLAY americanOwners += toContractors; // revenue, then equity long interest = (long) (spent * INTEREST_RATE); // 4. SERVICE one year, on this pass americanMajority -= interest; // paid: taxes, forgone services americanOwners += interest; // received: they hold the paper double overridden = (double) (middleCount + majorityCount) / americanPeople; // 0.90 tranquility -= EROSION * overridden; // written. domesticTranquility is what is read. return Metrics.of(spent); // 5. REPORT reportedGain } protected static int forfeiture(Seizure s) { americanMajority -= s.value(); // taken from the bottom half return (int) s.value(); // retained by the seizing agency } protected static Attack retaliate(Attack a) { return a.mirrored(); } // No method in this class is overridden by any subclass. }
package us.nationalsecurity; import java.util.ArrayList; import java.util.List; import doctrine.coldwar.*; import static budget.Appropriations.SUPPLEMENTAL; // emergency; off-budget; outside the caps; no offset public abstract class PerpetualWar extends Doctrine implements Runnable { private final List<Commitment> commitments = new ArrayList<>(); protected int reportedGain; // audited quarterly, reported to Congress protected int unreportedCost; // written, never read protected abstract Warning[] foreseen(); protected abstract Iterable<Crisis> theatres(); protected abstract Resource[] requires(); protected abstract boolean stillJustified(); protected abstract boolean funded(); protected abstract int prosecute(Funding f); protected abstract int costOf(Operation o); @Override public final void run() { try { for (Warning w : foreseen()) Analysts.raise(w); } catch (Inconvenient e) { // intentionally empty } for (Crisis c : theatres()) { commitments.add(allocate(requires())); } while (stillJustified() && funded()) { reportedGain += prosecute(SUPPLEMENTAL); unreportedCost += costOf(currentOperation()); Congress.report(reportedGain); } reassess(); } // free() exists and has been called: see 2021 protected final void withdraw(Commitment c) { SURPLUS.deposit(c.materiel()); allocate(c.mission(), OVER_THE_HORIZON); // net allocation unchanged } private Response respond(Attack a) { return respond(retaliate(a)); } private void reassess() { Congress.awaitRelease(Executive.WAR_POWERS); Executive.awaitAssertion(Congress.ARTICLE_I); } }
package us.nationalsecurity; import doctrine.coldwar.*; public final class GrandStrategy extends PerpetualWar { @Override protected Warning[] foreseen() { return new Warning[] { new Blowback(WORLD), new OccupationWillNotBeBrief() }; } @Override protected Iterable<Crisis> theatres() { return WORLD.crises(); } @Override protected Resource[] requires() { return new Resource[] { BASES, TROOPS, GUARANTEES }; } @Override protected boolean stillJustified() { return americanEmpire > americanPeople && domesticTranquility != imperialInterests; } @Override protected boolean funded() { return true; } @Override protected int prosecute(Funding f) { SURPLUS.deposit(decommission(VEHICLES, ARMOR, OPTICS)); return warForEmpire(f); } @Override protected int costOf(Operation o) { return WORLD.casualties(); } }
package us.nationalsecurity; import doctrine.coldwar.*; import static budget.Appropriations.SUPPLEMENTAL; public final class WarOnDrugs extends PerpetualWar { private static final Enemy ENEMY = declare("public enemy number one", 1971); private int budget = SUPPLEMENTAL; @Override protected Warning[] foreseen() { return new Warning[] { new UseWillNotFall(), new HarmWillFallUnevenly() }; } @Override protected Iterable<Crisis> theatres() { return Cities.all(); } @Override protected Resource[] requires() { return SURPLUS.withdraw(); } @Override protected boolean stillJustified() { return threatLevel() > 0; } private int threatLevel() { return reportedGain; } @Override protected boolean funded() { return budget > 0; } @Override protected int prosecute(Funding f) { if (!consent()) return 0; // same gate, same dollars, never taken budget += forfeiture(seize()); return arrests() + kilosSeized(); } @Override protected int costOf(Operation o) { return incarcerated() + separated() + overdoses(); } }
package us.nationalsecurity; import java.util.List; import java.util.concurrent.Executors; public final class SteadyState { public static void main(String[] args) throws Exception { Executors.newFixedThreadPool(2).invokeAll(List.of( Executors.callable(new GrandStrategy()), Executors.callable(new WarOnDrugs()) )); } }
SteadyState is a small computer program that pretends to be the United States government at war. It has been running, in the story, since 1991. It has no way to stop.
The program has two halves. One half runs the wars overseas. The other runs the war on drugs at home. They share one thing: a pile of leftover military equipment. When the war overseas brings a vehicle home, it goes into a yard. When the war at home needs a vehicle, it takes one from the same yard. Nothing is thrown away. It is moved.
Each half keeps two numbers. The first is what it tells Congress: the gain, the wins, the arrests, the kilos seized. The second is the cost: the soldier who did not come back, the veteran arrested in his home town, the family whose savings were seized. The program computes the second number with the same care as the first. It just never sends it anywhere.
Before each pass, the program asks whether it should continue. It asks the question in dollars. The top ten percent of the country, who own about a hundred and eighteen trillion dollars, say yes. Everyone else, who together own about fifty-six trillion, say no. The yes wins, every time, because the question was weighed by money and not by people. There is a second version of the question in the code that counts people instead. Thirty-five million for, three hundred and fourteen million against. That version is written, correct, and never used.
The program decides whether the war is still justified by looking at four numbers. Is the empire, measured in dollars, bigger than the people, measured as bodies? Yes, because dollars and bodies are not the same kind of thing, and the program never noticed. Is the country less than perfectly happy? Yes, and it always will be, because the number was written down once, on the first day, and the program never reads the current one. Those four numbers are locked. Nothing typed at the console can change them. The program decides whether to continue using only the numbers no one can touch.
There is a review step, where Congress and the President are supposed to reconsider. It sits on the line after the loop, and the loop never ends, so the review is never reached. There is a vote to declare war. It is written and never called. There is a way to respond to an attack: hit back, then hit back for the hitting back, with no reason anywhere in the chain to stop.
You can play it. You send troops, bring them home, read what Congress was told, and read the ledger of what it was not told. You can try to stop the program. It will refuse three times, in the language a real compiler would use. The only thing that ends it is Ctrl+C, a signal from outside the program, from you.
That is the point of the game. Everything inside the program is exactly what the law allows, and the law allows it to run forever. Everything that could stop it is outside: the war money Congress could refuse, the 2001 authorization it could let expire, the equipment handouts to police it could end, the seizures it could ban, the casualty count it could make itself read. The game lists those by bill number. Every figure in it is real and sourced, and it will tell you where each one came from.
It runs in any browser, with no login and nothing to install, and it will tell you, in plain words or in code or both, what happened to a person each time you press enter.