Grobots - Old Stuff

Old News


(Devon 20070912) New experimental feature: the main view can be zoomed in and out by typing '+' and '-'. ('0' returns to the default scale.) This means you have more flexibility in how much of the world you can see at once.

(Devon 20070930) That flexibility includes making the minimap larger and more detailed than the main view. :) But Warren improved the graphics yesterday, so it doesn't actually look bad. The main view is also smarter about scrolling when following now.


(Devon 20061227) There's now a native OS X build, based on a patch by Daniel von Fange. Some niceties are still missing (no icon, dragging sides to the application doesn't work) but at least you don't need Classic any more.

For interoperability (particularly important when switching from Grobots Classic), Grobots now recognizes either CR or LF as a newline. This works on all platforms, so you no longer need to worry about converting line endings. is hungry

(Devon 20060507) The mailing list has been silently eating any messages sent to it for several days. Last time this happened, it coughed up the missing messages a few days later. If it doesn't get better, I'll set up a replacement mailing list.

Shared code

(Devon 20060315) Thanks to a patch from Tilendor, types can now share code. If there is a #code section before the first type, its contents are available in all types. This is convenient for communications code, which has sometimes been duplicated between types.

Built-in graphs

(Devon 20060223) The Statistics window now includes a graph of biomass over time. It's as useful as it sounds. It would be even more useful if it showed average biomass for all sides at once, instead of just one at a time. [20060409: now it does.]

Windows and Linux ports

(Devon 20051111-12) I have ported Grobots to Windows. Not everything is done yet, but it's enough to be useful. Download the starter kit or just the binary.

Also, Warren ported headless mode to Linux.

Robots running around with their heads cut off

(Devon 20050828) Grobots can now be built with no user interface. This version runs from a command line and is easy to port. So easy, in fact, that I made a Windows build. This may be useful for people with slow Macs and fast Windows machines. You can't watch the rounds, but you can at least run tournaments.

Daniel von Fange implemented the first version of this in December, and used it to generate some interesting graphs. I only now got around to porting and uploading it. Someday I (or someone else) may get around to adding built-in graphs.

Yay! Only nine windows!

(Devon 20040911) I was going to make the inspector prettier, but it's not much use for anything but robots. So I removed it. Basic information about the selected object is now shown as a caption in the main view. (This looks nice with autofollow.) More detailed information about robots is in the debugger. It only shows the most interesting hardware variables, since there are too many to show them all. If there are more variables you want added, let me know.

Then I got rid of the Status window too. The profile times are now shown in the debugger when no robot is selected. The object counts and energy totals replace the type list in the Statistics (previously Scores) window when no side is selected. The frame and framerate are at the top of the roster. (They were briefly in the debugger, but were too inconvenient there.)

New sensor features

(Devon 20040815) It would be nice if sides could sometimes coexist without fighting. The simplest way to do this is to ignore cells that aren't attacking you. Missiles make this difficult, because you can't tell they're hostile until it's too late. So we added robot-bomb, which tells how much bomb a cell is carrying.

There's also robot-reloading, which tells whether the target's weapon has fired. (It may change to tell how fast the target is reloading.) This is so you can determine whether a cell is attacking without a shot-sensor and without waiting to be damaged.


(20040322) The main Grobots website is now at Please update your links.


(20040307) No more Grobots is free software, but we haven't settled on a license yet. Now it's under the GNU General Public License.


(20040105,09) The scoring system now keeps track of whether a side has any cells with constructors left. If not, the side is sterile, and is marked as such on the roster. This makes it easy to distinguish the many times when Not Quite Harmless retains only a few unkillable decoys from its long-dead population. Sterility also replaces extinction as the criterion for early and late death. There are now two different survival scores: the Scores view shows how often the side had any cells left, and the Tournament view shows how often it was not sterile.

No more tool-switching!

(20040105,08) Following, inspecting, and debugging a robot used to require several tedious switches between tools. Now it's automatic: just click on the robot with the Scroll/Follow tool. The inspector and debugger always show the currently followed object.

The Refollow (backquote), Follow Random (return, tab), and Autofollow (command-A) commands are useful too.

Warren scratches a personal itch

(Warren 20030727) I made a side debugger today, which currently only displays the shared memory for a side. By a remarkable coincidence, it works well for debugging a particular side I'm writing, which keeps statistics for each 10x10 tile of the world. The debugger displays shared memory 100 at a time, displayed in a 10x10 grid. It also calculates the min and max for each pane, and color-codes the display based on this. Of course, the debugger works fine for debugging sides that do not use shared memory in this particular way - the color-coding will just be less useful.

To use, select the side debugger from the view menu. To advance to the next/previous 100 numbers, hit the 'n' key / 'p' key. To return to the first 100, hit '0'.

Broken syphons

(Devon 20030721) I renamed syphons, so that the frequently used friendly syphons now have the short name syphon, and the rare enemy syphons are enemy-syphon. This breaks all fourteen syphon users. I've made fixed versions of the good ones.

While I was at it, I made syphon-distance measure from the center of the cell, not the edge. This makes syphons a little bit simpler to use. syphon-range still measures from the edge of the cell. Maybe it shouldn't.

A bug you can drive a 100-cell colony through

(Warren 20030705) I tracked down a bug today that made Commune and Untouchable have expenditures 20 to 50 percent higher than their incomes. Friendly syphons didn't conserve energy, and probably haven't for a little over a month. This explains part of Commune and Untouchable's success. I also fixed a bunch of less serious syphon bugs. Here's how syphons work now:

Yes, implicit conversions are bad

(Devon 20030516) I chased type ambiguities by removing an implicit type conversion operator, GBNumber::operator double. This broke a lot of code. That conversion was being used in a lot of places where it shouldn't have, and most of these weren't obvious. Some were even minor bugs.

I also added more comparison operators. If there are any type ambiguities left, please report them - my compiler doesn't. :(

New Top Nine tournament

(Devon 20030404) I started an organized tournament series. It's in KotH format. Read about it.

Seven-year patch

(Devon 20030114) We got our first patch today, from Tilendor. It makes GBSideReader portable, and ports GBErrors to Windows.

Oh, the original design of Grobots is seven years old this month, and the implementation three years.

Crush the giants

(20030103) We did some experiments with Intoxicated, and it seems that large cells still have an advantage in combat. They're supposed to have a large disadvantage. So we doubled the extra damage for large cells.

We're not specifically trying to weaken Intoxicated, Teledont, and World Toad. These are all interesting sides. But their size does not fit our vision of the game. Grobots is supposed to be about strategy and programming, not about who can buy the largest cells.

A semi-giant, Active Large, won the first tournament after the rule change. Not as bad as before, but still not good. Fortunately (and unlike Intoxicated), most of its success isn't due to its size.


(Devon 20021219) We removed the confusing increase in the cost of armor for large cells, and replaced it with an almost equivalent increase in damage taken. Whether it's equivalently confusing remains to be seen. This is, what, the fifth attempt to discourage large cells?

It's been nearly impossible to get much energy from manna. We didn't notice this until recently because theotrophs do unrealistically well in solitary doubletime tests. In an attempt to restore balance, we have increased the default manna rate, and the cost of solar cells.

There have been no tournaments recently because sides' performance varies so much under different rules (especially world sizes) and against different opponents. 10x10 tiles is standard, but we like the feel of the game in larger worlds. We will probably adjust constants to make the 10x10 world feel larger.


(Devon 20021124) Today's version replaces part of the cooling charge with an increase in the cost of armor for large cells. The idea is to compensate for large cells' combat advantage. Since large cells don't have an advantage in most other activities, a combat-specific penalty is better than a general one. (Ideally, we want large cells to be slightly worse at everything. The amount of cooling charge required to make them slightly worse at combat makes them much worse at other things.)

I added a Rules dialog, with which you can set various parameters, including seed size. Note that the world size settings don't work yet.

Source released

(Devon 20021121) Portability work is under way.

(Devon 20021119) We have released the source to Grobots. See the source page.

Quadratic cooling cost

(Devon 20021116) In order to get rid of the giant cells that have become too common, we made cooling cost increase as the square of hardware cost. This is cheaper for cells smaller than 2000, and very expensive for large cells: the marginal cost of hardware at 3500 is 50% higher than at 1000. Authors of large cells will probably want to shrink them.

To prevent many giants from becoming unseedable, we have raised the seed size to 6000. This is temporary; in a week or two (after sides have been updated) it'll return to 5000.

Automated tournaments

(Devon 20021116) There is now support for automating tournaments. Cumulative results are kept for all sides; type T in the Roster window to see them. Check the Tournament option in the Simulation menu to run many rounds automatically. Only ten sides at a time will be seeded (unless you uncheck the Only Seed Ten Sides option), so you can run large tournaments.

Views are much nicer now

(Devon 20021115) The various views update on a better schedule now. Minimap and Side no longer fail to update at all, and Inspector and Roster don't flicker so much. There's also a framerate display in the Status window. You can change the Minimap display; see the user interface reference. And the Type view works now, so you can see costs in detail. I found two bugs because of this.

Did you notice the visible indications of radio use, and the different colors of sensors?

Cooling charge and other size balance

(Devon, October 24, 2002) We decided to tackle the size-balance problem directly, by charging extra for large cells. If a cell's hardware costs over 1000, it is charged an additional 10% for a cooling system (because big things tend to overheat, right?). A cell that cost 1200 now costs 1220, which is not a big deal, but for larger cells, the charge is significant. Teledont's cost increased from 4899 to 5287, making it unseedable. (It's not a good idea to have sides that are just barely seedable; rule changes tend to break them.)

We also messed with explosions. Their size now varies even less than before. This greatly weakens missiles.

I finished adding AppleEvent support. This means you can open sides by dropping them on the application. Very convenient.


(Warren, October 12, 2002) #seed now works. See the docs for more detail. Also, the game automatically pauses when all but one side die.

(Warren, October 11, 2002) The Grobots compiler dared to insult me by rejecting the symbol nifr. I got angry and taught it a lesson. While I was at it, I also added nifc.

...and again

(Devon, October 3, 2002) Communications now requires hardware. This hardware is the first to use nonnumerical arguments: a full-featured radio is radio write read send receive. The arguments correspond to the communications operations that are supported. Sides that use communications will need updating again.

Sides broken again

(Devon, 2 October 2002) I renamed the communication operators, so sides that use them will need updating. Also added some new operators.

Have you noticed the tournament results and side analysis pages yet? Read them and go write something to end the reign of the missile-using autotrophs.

Enemies feel different

(Devon, September 21, 2002) In addition to collision, there are now friendly-collision, enemy-collision, food-collision, shot-collision, and wall-collision. See the documentation (yes, it's a new feature that's documented!) for details.

I ran some tournaments. Teledont is still champion.

Faster, and I forget what else

(Devon, September 21, 2002) I fixed a bug that made the minimap slow to draw. Now you no longer have to close that useful window to get acceptable speed. Also:

Now they look pregnant

(September 20, 2002) A cell's radius now varies with its mass, so pregnant cells are bigger. No more confusion over tiny cells that weigh far too much. I also fixed a random-number bug (2 1 random now works the same as 1 2 random), and added dist and in-range.

Listen to the vectors

(Devon, September 19, 2002) I added user-defined vector variables. They act like ordinary variables, but they store two values instead of one. Declare them with #vector name or #vector name x y.

There's also sound now. It can be annoying, so it's off by default.

Miscellaneous obscure bug fixes: brains now count toward biomass. Lines should no longer disappear from the background. About... menu item checked properly.

xor added

(Devon, September 3, 2002) See, we respond to feature requests! Slowly. But there's now an xor operator.

Several more changes

(Warren, June 9, 2002) More poorly tested changes:

Several changes

(Warren, May 26, 2002) Recent changes, of which none have been thoroughly tested, include:

Explosions changed

(Devon, May 2, 2002) Large explosions have been weakened. More massive robots also take more damage from explosions. See the physics page for details.

Foci back

(Devon, April 18, 2002) Sensor foci are back: use the variables *-sensor-focus-distance and *-sensor-focus-direction. Yes, I know their names are too long. Someday in the distant Utopian future, when the language is based on trees instead of sequences, there will also be more data types. Vectors, hardware, and sensor returns will all be first-class. food-sensor-focus-distance will become something like (norm (focus food-sensor)). Except that foci will be replaced by something better long before then.

I broke your sides.

(Devon, April 10, 2002) I made several incompatible changes yesterday, so most sides no longer work. Isn't it fun using prerelease software?

There's also a new operator: seek-location sets engine-velocity to go to a specified place at full power. It's strictly a convenience, but we got tired of writing it over and over, so now it's built in. This will happen a lot once we figure out what routines are useful.

Recent changes

(Devon, April 8, 2002) Some of the changes in the last few weeks:

There will be incompatible changes to sensors soon: reload times are going away, and the arguments to fire-*-sensor will be replaced by a *-sensor-focus variable.

Alpha version available

(Devon, March 6, 2002) The latest build of Grobots is now available. It's alpha-quality but the basics are all there, and it's fun to play. Download it (and some sides) and experiment. If you write any interesting sides, send them to us (or the mailing list). We'll post them on the site, and run tournaments.

Mailing list

(Devon, February 27, 2002) There is now a mailing list for Grobots. Send a message to to join, and to post. See for details.

All of the essential features are working. We will probably release an alpha version soon.

More new features?

(Devon, February 7, 2002) Added today: compile-time words, inter-robot communication, vector operations. Robot sensors now report the target's velocity. I also shortened some of the most unwieldy names: for example, food-sensor-angle-found is now food-angle.

Parser working!

(Devon, February 6, 2002) I finally finished the parser. Now arbitrary sides can be loaded from files - I've run five so far. This is a big milestone - now it's easier to play the game than to work on it.

Sensors have also been simplified and are now much easier to use. They are less informative to watch, but I can fix that.

Currently the biggest annoyances to the user seem to be:

Six years, no hurry

(Devon, February 4, 2002) Grobots is six years old. Changes lately:

More screenshots

(Devon, October 12, 2001) It seems I haven't posted any screenshots of the main view in a long time. Here are three, all showing robots engaged in somewhat useless activities.

Both the white and yellow sides in this screenshot run in circles, aimlessly fire a weapon, and do little else of interest. The yellow robots have raised shields (blue rectangles) to defend against the strafing, which is a waste of energy since those shots do practically no damage. Three of the syphons (little greenish crosses) aren't hitting anything, so they have no effect, and the fourth is starving a friendly robot.

Here, purple is throwing grenades at brown and white, but has not yet managed to kill anything. The white side's circular motion consistently throws off purple's aiming, so the grenades land in neat circles around the target. Purple did actually succeed in killing some brown robots shortly after this screenshot was taken. But as neither of the target sides is armed (white's strafing doesn't count), killing them is pretty pointless.

There's hope. This shows a nice healthy two-type plant and some nice healthy overkill. That cloud of grenades does 900 damage, enough to kill those heavily armored intruders three times over. Useless, but harmless. (Harmless to the plant, anyway.)

Status, changes, and To Do

(Devon, October 5, 2001) Work still continues, slowly. Some changes in the last few months:

More stuff to see

(Devon, June 20, 2001) The Roster window is working now. Notice the scoring information.

Major behind-the-scenes changes were made to the interface. Oh, and by the way, brains are working now.


(Devon, April 1, 2001) Apathy and frustration with C++ have prevented me from doing any significant work on Grobots since January. However, some nice features are working:

I am distracted by a more interesting project (and did I mention apathy?), so I may not be working on Grobots much.

More screenshots

(Devon, January 17, 2001) Here are two scenes from a battle, with and without sensor-shots, and the minimap.

Grobots is five years old!

(Devon, January 12, 2001) The first version of Grobots was designed five years ago this month. The design has changed surprisingly little since the first year.


(Devon, November 21, 2000) These screenshots are days old, but the graphics haven't changed since. The first one shows a bunch of brown Rabbits seeking food - the blue circles are their sensor-shots - and a white Lunatic that has fired a magenta blast at nothing in particular. The second shows five sides: the rabbit and lunatic, a dangerous purple gunner, a buggy red would-be predator, and green algae. Note the grey wall at the bottom.


(Devon, November 18, 2000) The Major Progress continues. There are now hard-coded sides fighting each other. This is a long-awaited milestone, as this phone conversation from yesterday illustrates:

The phone rings; Devon answers it.
Devon: Hello?
Warren, on the other end: Predator versus Algae?
Devon: Yup.

Major progress

(Devon, November 14, 2000) In the last two days, many major features have started working. The simulation now runs and displays.

Pick a language. Any language...

(Devon, date unknown) An implementation in C++ was started in January 2000. I abandoned it in favor of a Java implementation in April, but eventually got too frustrated with AWT and switched back.


(March 29, 2000) I made a fake screenshot!

Old Changes

Earlier changes weren't logged.

Old Screenshots

Other Old Stuff

There is an early description of Grobots. It's out of date but pretty complete. The documentation is better, though, and more up to date.

Grobots by Devon Schudy and Warren Schudy

Hosted by