Welcome SciREN folks!

Hello to everyone coming here via the SciREN event! This post will direct you to the some of the things you might be looking for. Always feel free to comment as well if you need help or want to share feedback.

The online simulators are here. If you are particularly interested in the niche partitioning simulator that I demoed at SciREN that simulator is the one called 100 Places.

Blog articles explaining each simulator are here.

There are some known bugs in some of these programs! Check here for those.

If you can’t find something drop me a comment.


RapidModel is Here

RapidModel is one of the original in-browser programs. This may be an odd thing to say since it’s only just appearing now, as the fourth project (or fifth, or sixth, depending on how you count the projects in beta) but it’s actually the second in-browser program I wrote. Much like the original version of CamoEvolve it needed some serious fixes. Unlike CamoEvolve it needed so many fixes that it really wasn’t workable, and so I took it down, re-wrote the code effectively from scratch (I kept a few drawing functions), and have now put it back up (having, in the meantime, re-written the whole site).

RapidModel is based on something I did in college. In one of our classes (probably Conservation Biology) we played around with a program where we could link items together and then play with sliders on them and see how they affected other items. I assume we built population models with this system, but I don’t really remember. RapidModel is similarly generic (but also free and does not require downloading).

At its most basic, RapidModel is a bunch of nodes that hold numbers with connections that cause the numbers in one node to influence the numbers in other nodes. The numbers in a node may represent anything – number of caribou, GDP, cans of beets – and the connections can take almost any form. So, without further ado, a brief explanation of the objects in RapidModel.


Nodes are just number containers. To create a node select Add/Edit Nodes and click on the black part of the screen. A new node will appear where you click and you’ll be asked to name the node. You’ll also be asked for:

Number: The number the node starts with. When you hit “Reset” the node will remember this number and reset to it as well.

Maximum: The number in the node will not exceed this number. In some cases the maximum is based on a real world constraint and in others it exists just to keep the model in some sane range.

Minimum: The number in the node will not drop below this number. For many real objects zero is a natural choice.

If you edit a node (which you do by selecting the radio button with the node’s name after creating a node) you can also choose to check Round to Integer. In this case the node will never display non-integer numbers. However, it does keep track of non-integer effects. So, for instance, if an integer node held a 2 and you subtracted 0.1 from it ten times in a round the node would drop to 1. If you subtracted 0.1 from it once a round nothing would happen for ten rounds, and then it would drop to 0. For many real-world items rounding to integers makes sense. There are no 0.3 whales or 0.71 consumers out there.


Connections can only be created in the sidebar. Create some nodes, selected Add/Edit Connections, and select Add New. Connections name themselves in a way that describes exactly what they do (for instance, a recent model of mine had a connection called “Seals-Sharks”) so you won’t be asked for a name but you will be asked for a start node and an end node. Circular connectors are fine. Calculators (which we’ll discuss next) can only be starting nodes. Here’s the important thing to remember: start nodes do something to end nodes. This is easy to think about with additive nodes. You take the number from the start node, go over to the end node, and add that start node number to the end node. What a start node does to the end node is determined by the node type, which is just a mathematical operator. Connection weights can be used modify how much of the start node is used to modify the end node. For instance, to grow a node by 50% a turn connect a node to itself with an additive connection of weight 0.5. You could do exactly the same thing by setting up a node that just held the number 1.5 and using it as the start node for a multiplicative connector of weight 1.


You create calculators much like nodes, which calculators are (technically) a subclass of. However, unlike nodes the important things that go on in calculators have to be done from the sidebar menu. Calculators have a set of arguments with exactly the same name as in nodes and these arguments (maximum, etc) function exactly the same way so I won’t re-describe them.

However, while calculators are programatically nodes they are ideologically very fancy connections. Unlike nodes they don’t retain a number for multiple turns, modifying it. Instead they calculate a value fresh every turn. Originally this was done by using dozens of connections and dummy nodes but calculators work much better. It’s the addition of calculators that made RapidModel usable. To use a calculator you must give it an equation. Equations can contains the names of nodes, numbers, and a small set of mathematical operators. Equations are written in a pretty straightforward manner: Squirrels/Trees gives you the number of squirrels per tree this turn. If you type an equation correctly you will see “No errors” when you hit enter. Otherwise you’ll be told what part of the equation was an issue. Calculators will also identify nodes that they draw numbers from and create yellow connections to them automatically.

The equation reader can only handle the following operators: +, -, * (multiplication), / (division), ^ (exponentials). It cannot handle order of operations. All equations are read left to right. So Squirrels/Trees/10+1 is equivalent to ((Squirrels/Trees)/10)+1.

Calculators can also be used to delay effects in a model. The delay time simply puts the calculator X turns behind the rest of the model. At the very simplest a calculator could simply take the value from another node a hold it for a certain number of turns (for instance, price responds to the demand of two turns ago). Because of the delay function the initial number of the calculator can be important. Perhaps you are multiplying by the output of a delayed calculator. If you start with 0 in the calculator you’ll zero out your next node as well, whereas if you started with 1 in the calculator nothing would happen for the turns before the calculator showed its first calculation.

So what does this look like?

Here’s a silly example. I want trees to grow slowly. I also want the squirrel population to grow but to be capped at 2 squirrels per tree. I made this model.

Trees and Squirrels are just nodes, set to round to integers. SquirrelsPerTree is a calculator with the equation Squirrels/2/Trees, which hits 1 when there are two squirrels per tree and stays under 1 when there are less than two squirrels per tree (as in this screenshot). Trees connects to trees with an additive connector of strength 0.1 which causes the population to grow by 10% per turn. (Again, while trees are integers, the accumulation of partial trees still eventually triggers the addition of a tree.) SquirrelsPerTree creates dummy connections (in yellow) that can’t be edited but which show that it uses both Trees and Squirrels for its calculations. Squirrels is divided by SquirrelsPerTree, so when there is extra space around the population expands. The minimum cap on SquirrelsPerTree can be used to lock the squirrel growth rate at some maximum and the maximum cap can be used to prevent the squirrel population from crashing violently.

I have no idea what you’ll use RapidModel for. I’ll definitely use it for population models in ecology this semester, but I deliberately made it extremely open-ended. If you do something fun with it leave me a comment.

Spiders Eating Bats and Fish

In honor of a recent presentation that I made at the North Carolina Museum of Natural Sciences Bugfest event I thought I would highlight two interesting articles relating to spiders. Both are from the open access journal PLoS ONE and so both are freely available to read to anyone with a working internet connection.

The first article is Bat Predation by Spiders by Martin Nyffeler and Mirjam Knörnschild. This topic is perhaps best introduced by the set of photos that accompanies the article.

Spider species that were found to have killed bats included both web-building and hunting spiders (which do not make webs). Most of the hunting spiders recorded eating bats were tarantulas. In several cases the predator appears to have been a member of the genus Avicularia, an arboreal tarantula genus that could easily access locations in trees where bats sleep during the day. In India one of the arboreal Poecilotheria species was recorded eating a bat. In other cases the tarantulas were ground-pounders, such as a large Lasiodora, a genus that includes the Brazilian salmon pink bird-eater. Other hunting spiders also got in on the action. A huntsman spider in India was recorded killing a bat and a fishing spider was recorded stalking a bat pup in Indiana. In both of these latter cases the predation event appears to have be interrupted by the observer.

Obviously, since spiders don’t fly, it’s much easier for web-building spiders to eat a delicious bat. The main culprits were members of the genus Nephila, the golden silk orb-weavers, whose webs can span 1.5 meters (roughly five feet) and whose bodies are the largest of all the web-spinning spiders. Other web weavers included other nephilids and members of the Araneidae, another orb-weaving family. Most of these spiders spin large webs and are themselves large spiders. North American readers may be familiar with the genus Argiope, of which one species, A. aurantia, the black and yellow writing spider, is found across a large section of the continent. These spiders represent some of the smaller species known to catch bats in their webs.

The bats caught in webs also tended to be small, with small microbats (often subadult) being the most common. Larger bats are likely to break through a web when they hit it, which would prevent them from being captured by web-building spiders. The heaviest bat reported captured in this study was an adult that probably weighed 11g, while another specimen could have weighed somewhat more.

The question of whether bats are actively preyed upon by spiders is also raised in this study. In some cases a bat may run into a spider web and become entangled and die of dehydration, exhaustion, or exposure without any active attempts at predation by the spider that made the web. In some of the cases cited here the full predation sequence was observed (attack, kill, feeding) whereas in other cases only the feeding end of the sequence was involved, and in some of the web spider instances only entanglement was observed. Oddly, this includes all the Nephila clavipes records, which may mean that even smaller Nephila kill bats entirely incidentally, and gain nothing by capturing such large animals in their webs. Larger Nephila species were observed to actively kill and eat bats.

Overall, this study concludes that bat predation by spiders is probably infrequent. A bat must fail at multiple steps to be killed by a spider. First, it must fail to avoid the web, and bats appear to be pretty good at avoiding webs. Second, the bat must become entangled in the web, when a large majority of bat-web impacts probably result in a destroyed web and a bat with some spider silk stuck to it. Third, the bat must fail to escape from the web. Since bats can struggle against the web and potentially break free this may result in some number of very brief bat captures. Obviously, active predation by the spider can prevent the successful escape of the bat, as the bat can be envenomated and crippled beyond its ability to break free even before it dies.

Many of the bats captured in this study were young, which may suggest that inexperience (and lower body weight) play an important role in leading to bat capture by spiders. The authors also suggest that echolocation frequency and nearness to home may play a role, as some bats are thought to rely on memory, and not echolocation, when close to their roost.

Finally, the authors ask whether bats are at all important to spiders as prey. For some spider species, they conclude, bats are so large that a single rare bat capture can sustain the spider for an extended period of time.

The second article is Fish Predation by Semi-Aquatic Spiders: A Global Pattern by Martin Nyffeler and Bradley J. Pusey. Clearly Martin Nyffeler is as interested in spiders killing vertebrate prey as I am. Again, a photo montage of spider-induced carnage seems appropriate.

As with bat predation, spiders were more likely to engage in fish predation in warm areas of the world, although in this case “warm areas” included a much wider band around the equator, with the largest number of records of fish predation coming from the United States. Again, the only continent without records of spider predation on fish is Antarctica. The authors note that, for instance, a long study in Canada observing Dolomedes triton never observed this species catching fish, whereas a smaller amount of observation time in Florida observed this same species capturing fish multiple times. This may be biased by the greater presence of small fish in warmer areas.

The family Psiauridae was responsible for most of the fish captures by a wide margin – roughly 80% of all fish captures came from this family. The genus Dolomedes (common in North America) was one of the primary culprits, with Dolomedes triton (five out of six of the images above) being one of the species with the most records. This group of spiders hunts at the water’s surface, and attacks fish through the surface of the water after directly touching the fish. Fish are then dragged out of the water to be consumed, which the authors note is necessary for the spiders’ method of feeding to work and also gives the spider an advantage in holding on to potentially-struggling prey.

The size of the fish captured was usually quite small. However, the spider was usually smaller. Fish were on average 2.2 times longer than the spider (unsurprising, given that fishes tend to possess longer body plans) and up to 4.5 times as heavy. Given my interest in catfish I do wish to note that one very small Ictalurus punctatus was reported as a prey item. Fish may also be made vulnerable by low oxygen levels (which drive fish towards the surface) and a tendency towards surface-feeding. The Gambusia mosquitofish seem especially vulnerable to being eaten by spiders.

Unlike spider predation on bats, spider predation on fish seems to be a normal (if often unobserved) behavior. Like predation on bats, a spider that successfully kills a fish can be expected to derive quite a lot of benefit from this kill.

Both of these papers noted something that should be, but isn’t always, obvious: many spiders are generalist predators with very simple means of determining whether something is prey or not. Prey specificity in spiders is probably normally quite low. For web-spinning spiders the rule is probably something like “what struggles without escaping is lunch”. Fish-eating spiders may have slightly more complex rules by which they determine that they can haul a struggling fish to shore but again things like estimated size are probably more important than taxonomic placement of potential prey.

Possibly more interesting in a general context, all of these events involve a smaller predator bringing down larger prey. Most predators do the opposite (a house cat, for instance, hunts mostly mouse-sized animals). The advantage that webs and venom give spiders is apparently sufficient to allow them to break the “rules” governing predator-prey size relationships. I’ll probably write more on that eventually but that will have to wait until I get time to do a full write up on what we know about Harpagornis moorei.