Why browsers are bloated

Inactive tabs (or minimised windows for that matter) shouldn't need any repainting.

Where can I tweak this parameter? Please expand on this, I'm interested.

JS

So the question remains, is there a unique DOM event that would fire solely for this throttling, to warn the web app of the slowdown?

code coming out looking more like a poor man's Macromedia Flash.

No. I don't even know any assembly.

runtime array bounds checks

no generics
respectable

Define a container that can hold several types of elements.

Define a fold function that works on several types of containers.

Can C do that without C "macros"?

int fn(void *, void *)

if (fn(&bp[i * size], arg) == 0)
bp[i * size]

No automatic dispatch ...

This implies that the container is indexable and, what's worse, contigious. How are you going to fold/map a tree then? C is useless.

visitor pattern

One thing that I don’t yet understand though, is how this plays out with memory usage.

bytes
bytes
bytes

loop array_fold_loop

GDI is ancient shit

Programmers don't give a shit about "bytes", "bits", "cycles" or any of that sewer infrastructure that has the honor of running programs.

Because wasting time on floor-scrubbery means having less time to actually write useful programs.

I just want to see the faces on those mainstream browser developers when a pure and simple GDI-based solution blows away their bloated renderer that needs a several-times-faster GPU...

For example, compare how to do something that should be simple in OpenGL, like rendering some vector graphics

As for porting, not so concerned - libXt/Xaw or whatever it's called on *nix should provide equivalent functionality on any system with X11.

but on Windows it's far more bloated because it has to drag along its own *nix GUI libraries and doesn't even feel like a native application.

The fact that you think bézier curves would be "the one thing that should be simple to implement in OpenGL" shows that you don't have any understanding of the graphics pipeline. GPUs are not magic graphics pixie dust, they're machines that eat vertices and shit pixels.

However, if you ignore the arbitrary vector SVG shit like I thought you would want to, then 99.99% of graphics rendering is going to be basic shit like rectangles, lines, circles, and scaled images, that any GPU can chew through with ease.

I hate to stick up for Cudder, but in the olden days we had some shitty yet remarkable support for analytic objects, which weren't described in verts. So it might just work.

Not so. Have you heard of floats, reflow? This shit is everywhere and it sucks. Once thats done, you sure can shit it out of a GPU pretty quick, but the GPU does the least of the work in the end so who cares?

I believe most early graphics hardware basically consisted of one or two fast serial DSPs,

GPU-accelerated font rasterization, which isn't a terrible idea come to think of it.

Because it can save CPU time that would be wasted on a task it isn't suited for while the GPU is mostly sitting idle,

That's not really the point. All cards can still do it (just not in "modern GL"), and the output quality is as good as the display can handle. If you're linking GL, you might as well use it.

It's been done.

It's neat, but it chews up your entire GPU with only a single column of text. The reflow on a modern web page (or desktop) is harsh.

You do get a boost out of it, but it's tiny by comparison.

PS. I hate to break it to you, but scrolling isn't just blitting, a lot of sites modify the DOM in scroll handlers.

I'm aware of a library that precalculates all the glyphs into a texture and renders like a bitmapped font, but that's not exactly the same.

Eh, I don't see why i.e. FreeType would be any faster at rendering the glyphs.

[citation needed]

But Cudder-sama is ignoring those parts of the spec.

You're still missing the point. "You can almost always do things better yourself." Analytic objects? Really? They look really good in GL, for what they are at least. You're going to spend a lot of time doing a bad job of it, that's what you're going to do.

Because merely rendering glyphs doesn't render text.
I forget what the exact problem was, but it was pretty fundamental. I think it had something to do with the amount of data required to represent the glyphs created a lot of tension, and used up a lot of the GPU. Sure, it was faster, but so much less efficient that it isn't really worth it to actually do it (i.e. you do want to draw graphics with your card, right?) Keep in mind you have kerning, reflow and all that stuff to worry about, and yes, you need to do it on the GPU or else you will just waste time copying data back and forth.

Text rendering, not layout, kerning, etc.

That's not how you fuck a training dog