Nomic Game

A paperwork table game, 2-6 people, permitting each member to vote on rules and score Stones or points awarded. A SelfModifyingGame.

See the Nomic FAQ at

Perhaps the best introduction is the homepage of the inventor.

The Initial Set of Rules is here:

Not necessarily paper. Agora [] has been around since 1993 and is still going strong; it's an email-based NomicGame. Check the FAQs and join in, it's fun. (I was a Player there for over 2 years; RealLife intruded at some point, but I might join in again sometime.)

Quintessentially, the NomicGame is a game where the object of the game is to change the rules of the game (up to and usually including what the object of the game is). Voting is one possible way to do so, but by no means the only one; some Nomics start out as dictatorships where you may suggest change a rule to the Dictator who has sole discretion over whether it is adopted.

The NomicGame is (to those who invest the necessary intellectual effort) an education in law, but also philosophy, semantics, and silliness. Heartily recommended.

-- LaurentBossavit

Other sources for the NomicGame:

There are a number of variants on the NomicGame theme. I guess the most important schism is between Imperial Nomic and the rest. - oa.

Imperial Nomic: A variant NomicGame, in which one of the players gets to decide if a proposal is adopted. That player, the Emperor, is usually barred from winning. -- OleAndersen

DvorakGame does it with blank cards.

Is it just me or does this remind any one else of CalvinBall?

No, CalvinBall has an immutable Rule to the effect that it can never be played the same way twice. Nomic (usually) has no such rule - which doesn't prevent the CalvinBall rule from applying to it, as EmergentBehavior. -- And more importantly, CalvinBall isn't allowed to have any other rules.
2-6 people

Has anyone even tried to play a NomicGame with only two players? It seems that 4 is the minimum to have any meaningful interaction. 3 is pushing it. So perhaps it should say 4+ people.

I once tried. I made a pretty good effort at it, but it was simply uninteresting. Using the rules which were the premise of "autonomic" (a short-lived email Nomic I once started), that effectively give each player total control over a subset of the rules, didn't help either. --DanielKnapp

Email games have grown much larger than 6 players. Agora Nomic has had a significant influx recently (due to being SlashDotted) and now has around 30 players. --MalcolmRyan?

Tegwar note moved to MorningtonCrescent. -- OleAndersen

We have a WikiNomic, by the way.

An except from the Nomic FAQ at:

Asking the question "What is Nomic?" is like asking the question "What is a hacker?" or "What is Zen?" - people tend to get all mystical and cryptic, and you end up with no real idea at all. :)

Nomic is a game, and it is a lot of FUN! Unlike most games, the rules of nomic are not written in stone. In fact, the object of the game is to make changes to the rules of the game. Players start off following some "initial rule-set", which dictates how the rules can be changed. Once a rule change has been made, players then follow this new rule set. Most importantly, the rules about how rule changes are made can themselves be changed!

This is where it tends to get mystical, because as a result of these rule changes, the game you are playing will change from moment to moment. The nature of the rule changing mechanism might change from democratic to capitalist, to totalitarian, to whatever. Or the ability to change the rules might be removed entirely - perhaps the game will turn into chess, or tag, or snap. The future of the game is entirely in the hands of the players.

In the words of Nomic's author:

Nomic is a game in which changing the rules is a move. In that respect it differs from almost every other game. The primary activity of Nomic is proposing changes in the rules, debating the wisdom of changing them in that way, voting on the changes, deciding what can and cannot be done afterwards, and doing it. Even this core of the game, of course, can be changed. -- PeterSuber, "How to Play Nomic"

Most nomic enthusiasts seem to enjoy playing nomic in order to experience the possibilities of different kinds of lawmaking processes, and also to exercise their ingenuity in trying to discover loopholes in the rules which give unusual results - mostly to the benefit of the player. (This is called "scamming", and is lots of fun! :)

In my commentary on the game I distinguish 'procedural' from 'substantive' games. In substantive games, players play to earn points and win. In procedural games, they try to tie the rules into knots, either for the logical fun of it or in order to win by paradox rather than by points. -- PeterSuber

For the record, Nomic was conceived and designed by PeterSuber, and first published in DouglasHofstadter's column "MetamagicalThemas?" in Scientific American in 1982, and later in Hofstadter's book, by the same name. Peter revised the rules and published them in his own book, TheParadoxOfSelfAmendment? in 1990.

For more information, see the NomicWiki? at

Has anyone thought about or tried a Nomic game where the rules are codified by a computer program? One could start with a relatively simple program and a file/database containing the initial game state, which would be a list of players and their initial scores of zero. In its initial state, running the program will increment the current player's score by some random amount (similar to the standard Nomic die roll), and declare the player to have won if the score goes over 100.

A move would consist of proposing some change to the program, committing that change if accepted by the other players, and then running the current version of the program. The program does whatever it does to the game state, and then declares a winner if somebody has met whatever the victory conditions are.

The program should probably be written in a simple ScriptingLanguage, such as Python, Ruby or Tcl, both to keep changes simple and to make it understandable to as many programmers as possible. A VersionControl system is probably a must.

Of course, in addition to the program, there would have to be a set of real-world rules to follow, directing how the program can be changed and by whom, how it is to be executed, how to interpret its output, etc. These rules would, of course, be changeable just like the program.

I think the basic victory rule should be "A player shall be declared the winner if running the program produces output containing the text '<player-name> has won the game.'" If running the program leads to a crash or syntax errors, it doesn't interrupt the game: it is simply up to the next player to propose a change to the program that makes it work again.

It might also make sense to make a player the winner if the player is able to get other players to accept a change that makes the program erase itself, go into an infinite loop, or otherwise make it impossible for the program to be started or to halt.

Whereas traditional Nomic emphasizes legislative and semantic skills, this kind of Nomic would give the players a CodeReview workout. It could be an entertaining way to learn a new programming language. This form of Nomic would be acceptable for a two-player game, due to the "unpredictability" of the modified program.

I'm thinking about writing an initial program and set of rules for a game like this. Does anyone have any interest in playing?

-- KrisJohnson

What language would we start with? (as per above, would probably make sense to start with a language that none of the players are terribly familiar with) --WilliamUnderwood

This game is about introspection and self referencing. Playing the game is best implemented by interacting with the same program that is being modified by the moves. If the players vote on changes and then run the program, then the most important part (i.e. the voting itself) cannot be changed by changing the program which is bad.

The language must be highly dynamic to allow changes at runtime and have great introspection capabilities in order to allow rules to reference other rules in a meaningful way. Say, a Lisp running that's accepts forms to be evaluated if the players agree. The code for voting, input is of course part of the program itself. Almost everything is within the program, the only thing I can think of that's not is the feedback from the environment: when the program terminates it returns the name of the winner.

-- GaborMelis?

I think that an InformLanguage variant might be an option, provided that it could have a good way to change definitions at runtime and interpret complex rules, but also low-level command interpretation. This could be some syntax for adding a new rule in the form of a new action which can be taken:
     To hyperpulse (a target T):
          while T can be burned:
              burn T.
     The past-tense of hyperpulse is hyperpulsed.
     A player can hyperpulse if they have not hyperpulsed within the last twenty rounds.


View edit of February 19, 2011 or FindPage with title or text search