traffic-simulation.de

The onramp microsimulation on traffic-simulation.de is an interactive model of how vehicles merge from an onramp into a main traffic stream. It shows that congestion at onramps is not simply caused by "too many cars," but by how inflow, merging pressure, and driver behavior interact. You can adjust general inflow, onramp flow, truck percentage, and individual driving parameters, then watch whether traffic stays free-flowing or breaks down into a jam. It is best used as a conceptual demonstration of traffic flow dynamics, not as a calibrated prediction of a specific real-world highway.

What the simulation actually models

The page presents a microscopic traffic model, meaning each vehicle is simulated individually rather than as a smooth fluid. Two behavioral layers drive the results:

• Car-following behavior — how a driver adjusts speed based on the vehicle ahead. Key parameters include desired maximum speed (v0), time gap (T), and maximum acceleration (a).
• Lane-changing behavior — how and when drivers change lanes, including politeness, a lane-change threshold, and separate right-bias settings for cars and trucks.

The onramp itself adds a merging stream. Vehicles entering from the ramp must find a gap in the main flow, which couples the two behaviors: a driver may need to change lanes or adjust speed to merge, and surrounding vehicles may need to react.

Why onramps become bottlenecks

An onramp concentrates several effects in one place:

1. Added demand — the onramp flow increases the total number of vehicles the downstream road must carry.
2. Forced lane changes — merging vehicles must enter the main stream, and through-traffic may shift left to make room.
3. Local speed reduction — a merging vehicle often travels slower than the main flow, so following vehicles brake.
4. Instability — small disturbances (a single brake tap) can amplify into a standing wave or full breakdown when density is already high.

This is why an onramp can become congested even when the main road upstream looks fine: the bottleneck is created by the merging interaction, not by the road geometry alone.

Reading the controls and what to test

The interface exposes several inputs. Their practical meaning:

A useful experiment sequence:

1. Start with low general inflow and low onramp flow. Confirm traffic stays free-flowing.
2. Raise onramp flow gradually. Note the point where merging vehicles begin to force main-flow braking.
3. Raise general inflow as well. Observe whether breakdown happens suddenly or gradually.
4. Increase truck percentage. Compare how much earlier congestion appears.
5. Reduce the time gap or increase politeness. See whether merging becomes smoother or more disruptive.

The Ramp-Metering Game on the page turns this into a control task: you regulate onramp flow to keep the main road flowing. It demonstrates the core trade-off of ramp metering — holding back ramp vehicles to protect mainline throughput.

What the results mean, and what they don't

The simulation illustrates general mechanisms:

• Traffic breakdown at onramps is a dynamic instability, not just a capacity limit.
• Ramp metering can preserve mainline flow, but at the cost of queuing on the ramp.
• Driver parameters (time gap, politeness, acceleration) materially change when and whether congestion appears.

It does not give you engineering-grade forecasts. The model is a simplified, generic representation; real onramps depend on geometry, signage, speed limits, vehicle mix, and local driving culture. Treat outputs as qualitative illustrations of cause and effect.

Where to go next

The page links to the underlying sources on GitHub (MovSim) and to the book Traffic Flow Dynamics / Verkehrsdynamik by Martin Treiber, for readers who want the equations behind the model. If you want to understand merging and bottleneck formation conceptually, running a few controlled experiments with the controls above will teach more than reading a static description.

traffic-simulation.de is a free, browser-based microsimulation of traffic flow built around an onramp scenario. It is a research and teaching demo rather than a commercial product: you open the page, watch individual vehicles (each simulated separately) merge and interact, and adjust the parameters that govern their behavior. No installation or account is needed — it runs in the browser using an HTML5 canvas. If your browser does not support the canvas tag, the simulation will not display.

What the site actually is

The page is titled "Microsimulation of Traffic Flow: Onramp" and is credited to Martin Treiber. It sits alongside the MovSim project (with sources on GitHub) and his books Traffic Flow Dynamics and Verkehrsdynamik. That context matters: what you are looking at is a visualization of a traffic-flow model, not a game with levels or a planning tool for real roads.

"Microsimulation" here means each car is modeled as an individual agent with its own speed, acceleration, and gap to the vehicle ahead, rather than treating traffic as a continuous fluid. The onramp is the focal scenario because merging behavior is where many traffic phenomena (congestion, capacity drops) become visible.

What you can do on the page

The main interactive element is the Ramp-Metering Game. Ramp metering means controlling how many vehicles are allowed to enter the highway from the onramp, usually via a signal, to keep mainline traffic flowing. In the game you try to manage that inflow and see the consequences.

Beyond the game, the page exposes simulation parameters you can change, grouped by behavior:

Changing these lets you test how driver aggressiveness, vehicle mix, or lane discipline affect the resulting traffic patterns.

How to use it

1. Open traffic-simulation.de in a browser that supports HTML5 canvas (any current version of Chrome, Firefox, Edge, or Safari).
2. Watch the default run to see baseline behavior on the mainline and the onramp.
3. Adjust one parameter at a time — for example, raise the onramp flow or lower the time gap T — and observe what changes.
4. Try the Ramp-Metering Game to see how controlling inflow affects congestion.

The value comes from changing one variable and watching the effect, since the parameters interact: a lower time gap (T) lets cars follow more closely, which can raise capacity but also make breakdown more likely.

Who it is for

• Students and learners who want to see car-following and lane-changing models in action instead of only reading equations.
• Researchers and educators who want a quick, no-setup way to demonstrate traffic-flow concepts, with the underlying MovSim code available on GitHub.
• Curious visitors who want to play the ramp-metering game and get an intuition for why onramps cause congestion.

It is not a tool for designing a specific real-world intersection, and it does not produce engineering reports — it is an educational and exploratory simulation.

Practical notes

• No pricing or login is indicated on the page; it presents itself as an open demo tied to the author's research.
• The simulation depends on the HTML5 canvas, so an old or restricted browser will show nothing.
• The GitHub link and the two books are the route to the underlying models if you want to go beyond the interactive page.

The traffic-simulation.de onramp page points to three offline resources: the MovSim source code on GitHub, the English-language book Traffic Flow Dynamics, and the German-language book Verkehrsdynamik. Use the GitHub repository if you want to read, run, or extend the simulation code; use the books if you want the theory behind the car-following, lane-changing, and ramp-metering behavior shown in the browser.

The GitHub source (MovSim)

The page lists its offline sources as "sources at GitHub" under the MovSim project. This is the practical entry point if you want to work with the model outside the browser.

What you can expect to do with it:

• Inspect how the simulation is implemented rather than only watching the canvas output.
• Run the model locally, which matters if you want repeatable runs or longer experiments than a browser session.
• Extend or modify behavior — for example the car-following and lane-changing rules that the onramp page exposes as adjustable parameters.

A reasonable workflow:

1. Open the MovSim repository on GitHub from the link on the site.
2. Read the repository's own build and run instructions — these are maintained with the code, so treat them as authoritative over anything summarized elsewhere.
3. Build and run a small scenario first to confirm your setup works before changing parameters or code.
4. Compare your local output against the browser simulation to check you have reproduced the same model.

The main friction point is that a research simulation repository assumes some familiarity with its build tooling and language. If you only want to understand the concepts, the books below are the faster route.

The two books

The site references two books, which cover the same modeling ground in different languages:

Both are attributed to Martin Treiber, who is also credited on the simulation page, so the books and the browser model come from the same modeling tradition. That makes them a coherent pairing: the simulation is a way to see the models in action, and the books explain why the models are built the way they are.

Which one to pick

• You want to modify or embed the simulation: start with the MovSim GitHub sources.
• You want to understand the parameters on the onramp page (car-following behavior, lane-changing behavior, and the flow controls): the books give the underlying model definitions.
• You want both: read the relevant book chapter first, then check the corresponding implementation in the repository — the mapping between equation and code is usually clearer in that order.

One caveat: the page itself does not state licensing, version, or supported platforms for the sources, and it does not give publication details for the books. Check the repository and the book listings directly for current information before relying on either for a project.

The Ramp-Metering Game on traffic-simulation.de is a browser-based interactive exercise built on the same microsimulation model as the site's Onramp scenario. You act as the ramp controller: you decide how much traffic is released from the onramp onto the main road, and the simulation shows what happens to the merging traffic and the highway flow as a result. It runs directly in the page and needs a browser with HTML5 canvas support — if canvas isn't available, the page shows a "Your browser does not support the HTML5 canvas tag" message instead of the animation.

What the game is actually testing

Ramp metering is the practice of holding vehicles at an onramp and releasing them in controlled amounts so they merge into gaps in the main flow rather than arriving in a platoon. The game turns that control decision into something you do by hand and watch in real time.

The underlying model is a microscopic traffic simulation: individual vehicles with their own car-following and lane-changing behavior, not a single averaged flow. That matters because congestion on an onramp usually starts as a local effect — one vehicle forced to slow for a merge — and then propagates backward. In the game you see that propagation happen rather than reading about it.

How a round works

1. The simulation starts with traffic on the main road and vehicles waiting on the onramp.
2. You control the release from the onramp — how many vehicles enter the main road and when.
3. Vehicles merge according to the model's lane-changing rules, which include a politeness factor and a lane-change threshold.
4. The animation shows the result: whether merging vehicles find gaps, whether the main flow slows, and whether a queue builds on the ramp or on the highway.
5. You adjust your metering and observe how the outcome changes.

The goal is to keep the merge from turning into congestion — releasing too aggressively pushes vehicles into the main flow faster than gaps appear, while releasing too conservatively lets the ramp queue grow.

The parameters behind the behavior

The game sits on top of the same parameter set exposed in the Onramp scenario. The page lists these controls:

These are the levers that determine how the simulated drivers behave. Politeness and the lane-change threshold govern how readily a driver accepts a gap; the right bias makes vehicles prefer returning to the right lane. Changing them changes how forgiving the merge is, which in turn changes how hard your metering job is.

What you can learn from it

The game is a way to feel the trade-off that real ramp metering faces:

• Release too much and merging vehicles disrupt the main flow, speeds drop, and a shockwave forms.
• Release too little and the ramp itself becomes the bottleneck, with a queue that can eventually spill back.
• The useful range is in between, and it shifts depending on the inflow, truck share, and driver parameters.

Because it uses the same model as the Onramp scenario, you can move between the two: experiment freely in the game, then inspect the parameter values in the scenario to see which settings produced the behavior you observed.

Practical notes

• The simulation runs in the browser; no installation is described on the page.
• Offline sources are linked from GitHub, and the model is documented in the book Traffic Flow Dynamics (and its German edition, Verkehrsdynamik), both referenced on the page.
• The page is credited to Martin Treiber.

If your browser doesn't render the canvas, the game won't run — that's the one hard requirement stated on the page.

The onramp microsimulation on traffic-simulation.de exposes four groups of adjustable parameters: traffic flow and inflow, vehicle mix, car-following behavior, and lane-changing behavior. You can change any of them before or during a run to see how the merging traffic responds. The controls are grouped in the page's parameter panel, and the model is a browser-based HTML5 canvas simulation by Martin Treiber.

Traffic Flow and General Inflow

These settings define how much traffic enters the system and how the onramp is fed.

• Traffic Flow — the mainline demand, i.e. how many vehicles per unit time enter the highway upstream of the merge.
• General Inflow — the background inflow that feeds the network.
• Onramp Flow — the demand arriving via the onramp itself. This is the key variable for studying merging and congestion at the ramp.

Raising onramp flow while holding mainline flow fixed is the standard way to push the merge toward breakdown; lowering it lets you observe free-flow merging.

Vehicle Mix and Timelapse

• Truck Perc — the percentage of trucks in the traffic stream. Trucks typically have different acceleration and speed characteristics from cars, so this changes both capacity and the dynamics of the merge.
• Timelapse — controls the playback speed of the simulation, letting you fast-forward through a long run or slow it down to watch a specific interaction.

Car-Following Behavior

These parameters govern how each driver follows the vehicle ahead.

• Max Speed v0 — the desired speed a driver aims for in free traffic.
• Time Gap T — the desired time headway to the leading vehicle. Smaller values mean tighter following and shorter gaps.
• Max Accel a — the maximum acceleration available to the vehicle.

Changing these shifts the fundamental diagram of the flow and therefore how early or late congestion appears near the onramp.

Lane-Changing Behavior

These settings control how and when vehicles change lanes.

• Politeness — how much a driver accounts for the disadvantage imposed on other vehicles when changing lanes. Higher politeness makes drivers more reluctant to cut in.
• LC Threshold — the lane-change threshold, i.e. the incentive level required before a driver decides to change lanes.
• Right Bias Cars and Right Bias Trucks — the tendency of cars and trucks respectively to keep to the right lane. Separate values let you model the common pattern where trucks stay right more consistently than cars.

How to Use These Together

A practical workflow is to set a baseline (for example, moderate mainline flow, low onramp flow, default car-following values), run the simulation, then vary one group at a time:

1. Increase Onramp Flow until merging congestion appears.
2. Raise Truck Perc to see how slower vehicles change the breakdown point.
3. Reduce Time Gap T or raise Max Accel a to test whether more aggressive car-following delays congestion.
4. Adjust Politeness and LC Threshold to see how cooperative or assertive lane-changing affects throughput at the merge.

The page also includes a Ramp-Metering Game and links to the offline sources on GitHub, the MovSim project, and the books Traffic Flow Dynamics and Verkehrsdynamik by the same author, which document the underlying models.