OpenTK instead of Tao

Yes, display lists should be faster in this case. The best ways to improve performance are to:

1. Draw more stuff with less calls. Modern hardware performs best when you draw at least (IIRC) 4096 vertices per draw call - anything less and it starts to stall.
2. Minimize state changes. Sorting everything by shader / texture will be much faster than binding a different shader / texture every time you issue a draw call.

Display lists help in both regards: you draw more stuff in one call and they driver may be able to minimize state changes.

However, before you go in and make any large changes, make sure you are benchmarking a release build (this includes OpenTK) ran outside of the IDE. It is a good idea to try a profiler, too - you wouldn't want to optimize something that isn't a bottleneck!

If you keep a different texture per tile, you can improve performance a lot by drawing all grass tiles first, all water tiles next, etc.

Instead of this (pseudo-code):

for (int y = 0; y < map.Height; y++)
{
    for (int x = 0; x < map.Width; x++)
    {
        // Bind texture
        // Draw tile map[x, y]
    }
}

you can do this:

// When you load your map, sort the tiles by texture:
Dictionary<Texture, List<Point>> sorted_tiles = new Dictionary<Texture, List<Point>>();
for (int y = 0; y < map.Height; y++)
{
    for (int x = 0; x < map.Width; x++)
    {
        if (!sorted_tiles.Contains(map[x, y].Texture))
            sorted_tiles.Add(map[x, y].Texture, new List<Point>());
 
       sorted_tiles[map[x, y].Texture].Add(new Point(x, y));
    }
}
 
// In your draw function
foreach (var texture in sorted_tiles.Keys)
{
    // Bind texture, then
    foreach (var point in sorted_tiles[texture])
    {
        // Draw tile map[point.X, point.Y]
    }
}

This way you reduce the number of times you need to call GL.BindTexture, which can give a nice performance boost. How nice? Try commenting out your BindTexture calls and see if your fps improve.

This shouldn't happen. Are you, by any chance, drawing to the front buffer? (This is no longer supported in OpenGL).

As long as you don't call GL.DrawBuffer(DrawBufferMode.Front) and call SwapBuffers at the end of the RenderFrame event, there shouldn't be any flickering at all.

What does the flickering look like? Does the whole screen flash between black and color? Only the tiles? Can you capture it in a screenshot?

Finally i found the error:

I do not update the mapdata every frame. So if i set the todraw[i] = -1; -> the nextframe do not do anything and just clears the map...

This works fine:

List<int> list = new List<int>();
foreach (int i in todraw)
{
	if (!list.Contains(i))
	list.Add(i);
}
 
foreach (int i in list)
{
	Textures.BindTexture(i);
	for (int j=0;j < 600;j++)
	{
		if (i == todraw[j])
		{	
			GL.DrawArrays(BeginMode.Quads,j*4,4);
		}
	}
}