Hi Jorge, I fully agree with your comments on my buffering patch. We should focus on the real solution, which is to fix the fltk library and then use their code for offscreen drawing. Whoever needs it can apply the patch manually. Regarding the frequent redraws I made the following observations: * Redraw requests are accumulated by fltk and then result in a single redraw when fltk thinks it should actually do the drawing. * Current code issues a full redraw request even if only part of the screen needs redrawing. This is a commented deficiancy and can be fixed quite easily. However there are so many full redraw requests, that one will hardly see any difference by that change. * Most full redraw requests come from Layout::queueResize() which in turn causes Layout::resizeIdle() to be called when fltk is idle for a moment. Every change of the size of a widget may change the whole layout on the screen and therefore require a complete redraw. If I understand the code correctly this is the similar in dillo1. So what can we do? For the second point I can provide a patch that accumulates screen regions that need redrawing until fltk actually redraws. The last point is more difficult to improve. For example think of a long page containing just text. Every time a new chunk comes in over the net, dillo creates a redraw request for the whole screen, even though there is already enough text to fill the screen so that the new data does not actually change the layout of the part that is currently visible. But how can we know, whether new data changes the layout of the currently visible part or not? The only rather simple improvement I can think of is that we could use the image sizes provided in the <img/> tags and only issue a Layout::queueResize() if the image proves to be of a different size. Currently there is a Layout::queueResize() for every image as it gets loaded. Regards, Johannes