Why do Vertex Buffer Objects improve performance? From my basic understanding, a Vertex Buffer Object works something like this (pseudo code):

Normally, if one wanted to say, draw a square, one could issue line drawing commands.

line (0, 0) -&gt; (1, 0)
line (1, 0) -&gt; (1, 1)
line (1, 1) -&gt; (0, 1)
line (0, 1) -&gt; (0, 0)


Using a VBO, if I understand correctly, would load the vertices into a VBO.

define VBO
load (0,0) -&gt; VBO
load (1,0) -&gt; VBO
load (1,1) -&gt; VBO
load (0,1) -&gt; VBO
load (0,0) -&gt; VBO


Then you can issue one drawing command.

draw VBO vertices


While I understand how VBOs work, I don't know why they improve performance. 

How do they improve performance?
In general, when you render an object in an immediate mode—issuing line drawing commands for instance—you build up a series of commands that you submit to the graphics card to draw. If you're drawing a lot of data, or drawing very frequently, you can waste a lot of time sending this data over and over again.

A vertex buffer allows you to produce a single object that you submit to the graphics card once. If you don't need to change your geometry, you can leave it on the graphics card and simply send the graphics card a request to draw that object. Since it avoids the copy every time you draw, there's much less overhead for each draw.

Note that using a vertex buffer object doesn't always provide a very significant speedup. If you're only drawing the object once per frame, and you're replacing the geometry in between each frame, then you don't get the benefits of avoiding the copy each frame.

Most of my experience comes from writing programs using graphics APIs like OpenGL, so someone who's messed with the backend of a graphics driver can probably provide a more detailed answer, but I hope this makes things a bit clearer.