The microsimulation uses a cellular automata (CA) technique for representing driving dynamics (e.g. [,]). The road is divided in cells, each of a length that a car uses up in a jam (we currently use 7.5 meters). A cell is either empty, or occupied by exactly one car. Movement takes place by hopping from one cell to another; different speeds are represented by different jumping distances. Using one second as the time step works well (because of reaction-time arguments []); this implies for example that a hopping speed of 5 cells per time step corresponds to 135 km/h. As long as no lane changing takes place, this just models ``car following''; the rules for car following in the CA are: (i) linear acceleration up to maximum speed if no car is ahead; (ii) if a car is ahead, then adjust velocity so that it is proportional to the distance between the cars; (iii) sometimes be randomly slower than what would result from (i) and (ii).
Lane changing is done as pure sideways movement in an additional ``half time-step'' before the forwards movement of the vehicles, i.e. each time-step is subdivided into two sub-time-steps. The first sub-time-step is used for lane changing, while the second sub-time-step is used for forward motion. Each sub-time-step requires the exchange of boundary information between CPUs. Lane-changing rules for TRANSIMS are symmetrical and consist of two simple elements: Check if the other lane is faster, and check if there is enough space to ``get in'' [].
Two other important elements of traffic simulations are signalized turns and so-called unprotected turns. The first of those can for example be modeled by putting a ``virtual'' vehicle of maximum velocity zero on the lane when the traffic light is red, and to remove it when it is green. Unprotected turns get modeled via ``gap acceptance'': There needs to be a certain gap on the priority street so that the car from the non-priority street accepts it [].