Introdução
O HTML5 oferece ótimas ferramentas para melhorar a aparência visual de aplicativos da Web. Isso é ainda mais válido para animações. No entanto, com esse novo poder também surgem novos desafios. Na verdade, esses desafios não são tão novos, e às vezes pode ser útil perguntar à sua colega de mesa, a programadora de Flash, como ela superou problemas semelhantes no passado.
De qualquer forma, quando você trabalha com animação, é muito importante que os usuários percebam que elas são suaves. Precisamos entender que a suavidade nas animações não pode ser criada simplesmente aumentando os quadros por segundo além de qualquer limite cognitivo. Infelizmente, nosso cérebro é mais inteligente do que isso. Você vai aprender que uma animação de 30 quadros por segundo (QPS) é muito melhor do que uma de 60 QPS com alguns quadros perdidos no meio. As pessoas odeiam serrilhados.
Este artigo tenta fornecer as ferramentas e técnicas para melhorar a experiência do seu próprio aplicativo.
A estratégia
Não queremos de forma alguma desencorajar você a criar apps incríveis e visualmente impressionantes com HTML5.
Depois, quando você perceber que o desempenho poderia ser um pouco melhor, volte aqui e leia sobre como melhorar os elementos do seu aplicativo. Claro que pode ajudar a fazer algumas coisas certas logo de início, mas nunca deixe que isso atrapalhe sua produtividade.
Fidelidade visual++ com HTML5
Aceleração de hardware
A aceleração de hardware é um marco importante para o desempenho geral de renderização no navegador. O esquema geral é transferir tarefas que seriam calculadas pela CPU principal para a unidade de processamento gráfico (GPU) no adaptador gráfico do computador. Isso pode gerar grandes ganhos de desempenho e também reduzir o consumo de recursos em dispositivos móveis.
Estes aspectos do documento podem ser acelerados pela GPU
- Composição de layout geral
- Transições do CSS3
- Transformações 3D do CSS3
- Desenho em tela
- Desenho em 3D do WebGL
Embora a aceleração do canvas e do WebGL sejam recursos de uso especial que podem não se aplicar ao seu aplicativo específico, os três primeiros aspectos podem ajudar praticamente todos os apps a se tornarem mais rápidos.
O que pode ser acelerado?
A aceleração de GPU funciona transferindo tarefas bem definidas e específicas para hardware de uso especial. O esquema geral é que o documento é dividido em várias "camadas" que são invariáveis para os aspectos da página que são acelerados. Essas camadas são renderizadas usando o pipeline de renderização tradicional. A GPU é usada para compor as camadas em uma única página, aplicando os "efeitos" que podem ser acelerados em tempo real. Um resultado possível é que um objeto animado na tela não exija um único "novo layout" da página enquanto a animação acontece.
O que você precisa entender é que é preciso facilitar para o mecanismo de renderização identificar quando ele pode aplicar a mágica da aceleração de GPU. Veja o exemplo a seguir:
Embora isso funcione, o navegador não sabe que você está realizando algo que deve ser percebido como uma animação suave por um ser humano. Considere o que acontece quando você alcança a mesma aparência visual usando transições CSS3:
A forma como o navegador implementa essa animação é completamente oculta para o desenvolvedor. Isso significa que o navegador pode aplicar truques, como a aceleração de GPU, para atingir a meta definida.
Há duas flags de linha de comando úteis para o Chrome que ajudam a depurar a aceleração de GPU:
--show-composited-layer-bordersmostra uma borda vermelha ao redor dos elementos que estão sendo manipulados no nível da GPU. É bom para confirmar se as manipulações ocorrem na camada da GPU.--show-paint-rectstodas as mudanças que não são de GPU são pintadas, e isso gera uma borda clara em todas as áreas que são repintadas. Você pode ver o navegador otimizando as áreas de pintura em ação.
O Safari tem flags de ambiente de execução semelhantes descritas aqui.
Transições do CSS3
As transições CSS facilitam a animação de estilo para todo mundo, mas também são um recurso de desempenho inteligente. Como uma transição CSS é gerenciada pelo navegador, a fidelidade da animação pode ser muito melhorada e, em muitos casos, acelerada por hardware. Atualmente, o WebKit (Chrome, Safari, iOS) tem transformações CSS aceleradas por hardware, mas isso está chegando rapidamente a outros navegadores e plataformas.
Você pode usar eventos transitionEnd para criar scripts com combinações avançadas, mas, no momento, para capturar todos os eventos de fim de transição compatíveis, é preciso observar webkitTransitionEnd transitionend oTransitionEnd.
Muitas bibliotecas agora introduziram APIs de animação que aproveitam as transições, se presentes, e usam a animação padrão de estilo DOM, caso contrário. scripty2, transição YUI, jQuery animate enhanced.
Tradução de CSS3
Tenho certeza de que você já animou a posição x/y de um elemento na página antes. Você provavelmente manipulou as propriedades left e top do estilo inline. Com as transformações 2D, podemos usar a funcionalidade translate() para replicar esse comportamento.
Podemos combinar isso com a animação do DOM para usar o melhor recurso possível
<div style="position:relative; height:120px;" class="hwaccel">
<div style="padding:5px; width:100px; height:100px; background:papayaWhip;
position:absolute;" id="box">
</div>
</div>
<script>
document.querySelector('#box').addEventListener('click', moveIt, false);
function moveIt(evt) {
var elem = evt.target;
if (Modernizr.csstransforms && Modernizr.csstransitions) {
// vendor prefixes omitted here for brevity
elem.style.transition = 'all 3s ease-out';
elem.style.transform = 'translateX(600px)';
} else {
// if an older browser, fall back to jQuery animate
jQuery(elem).animate({ 'left': '600px'}, 3000);
}
}
</script>
Usamos o Modernizr para testar transformações e transições CSS 2D. Se houver, vamos usar a tradução para mudar a posição. Se isso for animado usando uma transição, é bem provável que o navegador possa acelerar o hardware. Para dar ao navegador outro empurrão na direção certa, vamos usar a "bala mágica de CSS" acima.
Se o navegador for menos capaz, vamos usar o jQuery para mover o elemento. Você pode usar o plug-in de polyfill de transformação do jQuery de Louis-Remi Babe para automatizar todo esse processo.
window.requestAnimationFrame
O requestAnimationFrame foi introduzido pela Mozilla e iterado pelo WebKit com o objetivo de fornecer uma API nativa para executar animações, sejam elas baseadas em DOM/CSS ou em <canvas> ou WebGL. O navegador pode otimizar animações simultâneas em um único ciclo de refluxo e repintura, resultando em uma animação de maior fidelidade. Por exemplo, animações baseadas em JS sincronizadas com transições CSS ou SVG SMIL. Além disso, se você estiver executando o loop de animação em uma guia que não está visível, o navegador não vai mantê-lo em execução, o que significa menos uso de CPU, GPU e uso da memória, resultando em uma duração de bateria muito maior.
Para mais detalhes sobre como e por que usar requestAnimationFrame, consulte o artigo de Paul Irish requestAnimationFrame para animação inteligente.
Criação de perfil
Quando você descobre que a velocidade do seu aplicativo pode ser melhorada, é hora de se aprofundar na criação de perfil para descobrir onde as otimizações podem trazer o maior benefício. As otimizações geralmente têm um impacto negativo na capacidade de manutenção do código-fonte e, portanto, só devem ser aplicadas se necessário. A criação de perfil informa quais partes do código teriam os maiores benefícios se o desempenho delas fosse melhorado.
Criação de perfil do JavaScript
Os criadores de perfil de JavaScript oferecem uma visão geral do desempenho do aplicativo no nível da função JavaScript, medindo o tempo que leva para executar cada função individual do início ao fim.
O tempo bruto de execução de uma função é o tempo total que ela leva para ser executada de cima para baixo. O tempo de execução líquido é o tempo de execução bruto menos o tempo necessário para executar as funções chamadas pela função.
Algumas funções são chamadas com mais frequência do que outras. Os criadores de perfil geralmente mostram o tempo que levou para todas as invocações serem executadas, bem como o tempo de execução médio, mínimo e máximo.
Para mais detalhes, confira a documentação do Chrome DevTools sobre criação de perfil.
O DOM
O desempenho do JavaScript tem uma forte influência na fluidez e na responsividade do aplicativo. É importante entender que, embora os criadores de perfil de JavaScript meçam o tempo de execução do JavaScript, eles também medem indiretamente o tempo gasto em operações do DOM. Essas operações do DOM costumam ser a causa dos problemas de desempenho.
function drawArray(array) {
for(var i = 0; i < array.length; i++) {
document.getElementById('test').innerHTML += array[i]; // No good :(
}
}
Por exemplo, no código acima, quase nenhum tempo é gasto executando o JavaScript real. Ainda é muito provável que a função drawArray apareça nos seus perfis porque ela está interagindo com o DOM de uma maneira muito ineficiente.
Dicas e sugestões
Funções anônimas
As funções anônimas não são fáceis de analisar porque, por natureza, não têm um nome que possa aparecer no criador de perfil. Há duas maneiras de lidar com isso:
$('.stuff').each(function() { ... });
reescreva para:
$('.stuff').each(function workOnStuff() { ... });
Não é muito conhecido que o JavaScript permite nomear expressões de função. Isso vai fazer com que eles apareçam perfeitamente no criador de perfil. Há um problema com essa solução: a expressão nomeada coloca o nome da função no escopo léxico atual. Isso pode afetar outros símbolos, então tome cuidado.
Como analisar funções longas
Imagine que você tem uma função longa e suspeita que uma pequena parte dela pode ser o motivo dos problemas de desempenho. Há duas maneiras de descobrir qual parte está com problema:
- O método correto: refatorar o código para não incluir funções longas.
- O método maligno de fazer as coisas: adicione instruções na forma de funções de chamada automática nomeadas ao seu código. Se você tomar um pouco de cuidado, isso não vai mudar a semântica e vai fazer com que partes da sua função apareçam como funções individuais no criador de perfil:
js function myLongFunction() { ... (function doAPartOfTheWork() { ... })(); ... }Não se esqueça de remover essas funções extras depois que a criação de perfil for concluída ou até mesmo usá-las como ponto de partida para refatorar seu código.
Criação de perfil do DOM
As ferramentas para desenvolvedores mais recentes do Chrome Web Inspector contêm a nova "Visualização da linha do tempo", que mostra uma linha do tempo das ações de baixo nível realizadas pelo navegador. Use essas informações para otimizar as operações do DOM. Tente reduzir o número de "ações" que o navegador precisa realizar enquanto a execução de código é realizada.
A visualização da linha do tempo pode criar uma quantidade imensa de informações. Portanto, tente criar casos de teste mínimos que possam ser executados de forma independente.
A imagem acima mostra a saída da visualização da linha do tempo de um script muito simples. O painel esquerdo mostra as operações realizadas pelo navegador em ordem cronológica, enquanto a linha do tempo no painel direito mostra o tempo real consumido por uma operação individual.
Mais informações sobre a visualização da linha do tempo. Uma ferramenta alternativa para criação de perfil no Internet Explorer é o DynaTrace Ajax Edition.
Estratégias de criação de perfil
Destacar aspectos
Ao analisar o perfil do aplicativo, tente identificar os aspectos da funcionalidade que podem causar lentidão o mais próximo possível. Em seguida, tente fazer uma execução de perfil que execute apenas partes do código relevantes para esses aspectos do aplicativo. Isso facilita a interpretação dos dados de criação de perfil, porque eles não são misturados com caminhos de código que não estão relacionados ao problema real. Bons exemplos de aspectos individuais do aplicativo:
- Tempo de inicialização (ativar o criador de perfil, recarregar o aplicativo, aguardar a conclusão da inicialização, interromper o criador de perfil).
- Clique em um botão e na animação subsequente (inicie o criador de perfil, clique no botão, aguarde até que a animação seja concluída e interrompa o criador de perfil).
Criação de perfil da GUI
Executar apenas a parte certa do aplicativo pode ser mais difícil em um programa de GUI do que quando você otimiza, por exemplo, o ray tracer do seu mecanismo 3D. Por exemplo, se você quiser analisar o que acontece quando um botão é clicado, talvez acione eventos de passagem do mouse não relacionados ao longo do caminho, o que torna os resultados menos conclusivos. Tente evitar isso :)
Interface programática
Também há uma interface programática para ativar o depurador. Isso permite um controle preciso sobre quando a criação de perfil começa e termina.
Inicie uma criação de perfil com:
console.profile()
Parar de criar perfis com:
console.profileEnd()
Repetibilidade
Ao fazer a criação de perfil, verifique se é possível reproduzir os resultados. Só assim você vai saber se as otimizações realmente melhoraram as coisas. Além disso, a criação de perfil no nível da função é feita no contexto de todo o computador. Não é uma ciência exata. As execuções de perfil individuais podem ser influenciadas por muitos outros fatores no computador:
- Um timer não relacionado no seu aplicativo que é acionado enquanto você mede outra coisa.
- O coletor de lixo fazendo o trabalho dele.
- Outra guia no navegador que está fazendo um trabalho pesado na mesma linha de execução.
- Outro programa no computador está usando a CPU, o que deixa o aplicativo mais lento.
- Mudanças repentinas no campo gravitacional da Terra.
Também faz sentido executar o mesmo caminho de código várias vezes em uma sessão de criação de perfil. Dessa forma, você diminui a influência dos fatores acima, e as partes lentas podem se destacar ainda mais.
Medir, melhorar, medir
Ao identificar um ponto lento no programa, pense em maneiras de melhorar o comportamento de execução. Depois de mudar o código, faça o perfil novamente. Se você estiver satisfeito com o resultado, siga em frente. Se não notar uma melhora, é provável que você precise reverter a mudança e não deixá-la "porque não vai fazer mal".
Estratégias de otimização
Minimizar a interação com o DOM
Um tema comum para melhorar a velocidade dos aplicativos cliente da Web é minimizar a interação com o DOM. Embora a velocidade dos mecanismos JavaScript tenha aumentado em uma ordem de magnitude, o acesso ao DOM não ficou mais rápido na mesma proporção. Por motivos práticos, isso nunca vai acontecer (coisas como layout e desenho na tela levam tempo).
Armazenar nós DOM em cache
Sempre que você recuperar um nó ou uma lista de nós do DOM, pense se é possível reutilizá-los em um cálculo posterior (ou até mesmo na próxima iteração do loop). Isso costuma acontecer quando você não adiciona nem exclui nós na área relevante.
Antes:
function getElements() {
return $('.my-class');
}
Depois:
var cachedElements;
function getElements() {
if (cachedElements) {
return cachedElements;
}
cachedElements = $('.my-class');
return cachedElements;
}
Valores de atributo de cache
Da mesma forma que você pode armazenar em cache nós do DOM, também pode armazenar em cache os valores de atributos. Imagine que você está animando um atributo do estilo de um nó. Se você sabe que você (como parte do código) é a única pessoa que vai tocar nesse atributo, pode armazenar em cache o último valor em cada iteração para não precisar ler repetidamente.
Antes:
setInterval(function() {
var ele = $('#element');
var left = parseInt(ele.css('left'), 10);
ele.css('left', (left + 5) + 'px');
}, 1000 / 30);
Depois:
js
var ele = $('#element');
var left = parseInt(ele.css('left'), 10);
setInterval(function() {
left += 5;
ele.css('left', left + 'px');
}, 1000 / 30);
Remover a manipulação do DOM de loops
Os loops costumam ser pontos importantes para otimização. Tente pensar em maneiras de separar o processamento de números do trabalho com o DOM. Muitas vezes, é possível fazer um cálculo e, depois, aplicar todos os resultados de uma só vez.
Antes:
document.getElementById('target').innerHTML = '';
for(var i = 0; i < array.length; i++) {
var val = doSomething(array[i]);
document.getElementById('target').innerHTML += val;
}
Depois:
var stringBuilder = [];
for(var i = 0; i < array.length; i++) {
var val = doSomething(array[i]);
stringBuilder.push(val);
}
document.getElementById('target').innerHTML = stringBuilder.join('');
Redesenhos e refluxos
Como discutido anteriormente, acessar o DOM é relativamente lento. Ele fica muito lento quando o código lê um valor que precisa ser recalculado porque o código modificou recentemente algo relacionado no DOM. Portanto, evite misturar o acesso de leitura e gravação ao DOM. O ideal é que o código seja sempre agrupado em duas fases:
- Fase 1: ler os valores do DOM necessários para seu código
- Fase 2: modificar o DOM
Tente não programar um padrão como:
- Fase 1: ler valores do DOM
- Fase 2: modificar o DOM
- Fase 3: ler um pouco mais
- Fase 4: modificar o DOM em outro lugar.
Antes:
function paintSlow() {
var left1 = $('#thing1').css('left');
$('#otherThing1').css('left', left);
var left2 = $('#thing2').css('left');
$('#otherThing2').css('left', left);
}
Depois:
function paintFast() {
var left1 = $('#thing1').css('left');
var left2 = $('#thing2').css('left');
$('#otherThing1').css('left', left);
$('#otherThing2').css('left', left);
}
Essa recomendação deve ser considerada para ações que ocorrem em um contexto de execução do JavaScript. (por exemplo, em um manipulador de eventos, em um manipulador de intervalo ou ao processar uma resposta AJAX).
A execução da função paintSlow() acima cria esta imagem:
A mudança para a implementação mais rápida gera esta imagem:
Essas imagens mostram que reordenar a forma como o código acessa o DOM pode melhorar muito o desempenho de renderização. Nesse caso, o código original precisa recalcular os estilos e o layout da página duas vezes para criar o mesmo resultado. Uma otimização semelhante pode ser aplicada a basicamente todo o código do "mundo real" e gerar resultados realmente impressionantes.
Leia mais: Rendering: repaint, reflow/relayout, restyle, de Stoyan Stefanov
Redesenhos e o loop de eventos
A execução do JavaScript no navegador segue um modelo de "loop de eventos". Por padrão, o navegador fica em um estado "ocioso". Esse estado pode ser interrompido por eventos de interações do usuário ou por timers JavaScript ou callbacks Ajax. Sempre que um trecho de JavaScript é executado em um ponto de interrupção, o navegador geralmente aguarda a conclusão dele até que a tela seja atualizada. Pode haver exceções para JavaScripts de execução extremamente longa ou em casos como caixas de alerta que interrompem efetivamente a execução do JavaScript.
Consequências
- Se os ciclos de animação em JavaScript levarem mais de 1/30 segundos para serem executados, não será possível criar animações suaves, porque o navegador não vai repintar durante a execução do JS. Quando você espera também processar eventos do usuário, precisa ser muito mais rápido.
- Às vezes, é útil atrasar algumas ações do JavaScript por um tempo.
Por exemplo,
setTimeout(function() { ... }, 0)Isso informa ao navegador para executar o callback assim que o loop de eventos estiver inativo novamente (alguns navegadores esperam pelo menos 10 ms). Isso vai criar dois ciclos de execução de JavaScript muito próximos no tempo. Ambos podem acionar uma nova pintura da tela, o que pode dobrar o tempo total gasto com a pintura. Se isso realmente aciona duas pinturas, depende de heurísticas no navegador.
Versão normal:
function paintFast() {
var height1 = $('#thing1').css('height');
var height2 = $('#thing2').css('height');
$('#otherThing1').css('height', '20px');
$('#otherThing2').css('height', '20px');
}
Vamos adicionar um atraso:
function paintALittleLater() {
var height1 = $('#thing1').css('height');
var height2 = $('#thing2').css('height');
$('#otherThing1').css('height', '20px');
setTimeout(function() {
$('#otherThing2').css('height', '20px');
}, 10)
}
A versão atrasada mostra que o navegador pinta duas vezes, embora as duas mudanças na página tenham apenas 1/100 de segundo de diferença.
Inicialização lenta
Os usuários querem apps da Web que carreguem rápido e sejam responsivos. No entanto, os usuários têm limites diferentes para o que consideram lento, dependendo da ação que realizam. Por exemplo, um app nunca deve fazer muitos cálculos em um evento de passagem do mouse, porque isso pode criar uma experiência ruim para o usuário enquanto ele continua movendo o mouse. No entanto, os usuários estão acostumados a aceitar um pequeno atraso depois de clicar em um botão.
Portanto, pode ser interessante mover o código de inicialização para ser executado o mais tarde possível (por exemplo, quando o usuário clica em um botão que ativa um componente específico do aplicativo).
Antes:
js
var things = $('.ele > .other * div.className');
$('#button').click(function() { things.show() });
Depois:
js
$('#button').click(function() { $('.ele > .other * div.className').show() });
Delegação de eventos
Distribuir manipuladores de eventos em uma página pode levar um tempo relativamente longo e também pode ser tedioso quando os elementos são substituídos dinamicamente, o que exige a reatribuição de manipuladores de eventos aos novos elementos.
A solução nesse caso é usar uma técnica chamada delegação de eventos. Em vez de anexar manipuladores de eventos individuais a elementos, a natureza de propagação de muitos eventos do navegador é usada ao anexar o manipulador de eventos a um nó pai e verificar o nó de destino do evento para ver se ele é de interesse.
No jQuery, isso pode ser facilmente expresso como:
$('#parentNode').delegate('.button', 'click', function() { ... });
Quando não usar a delegação de eventos
Às vezes, o oposto pode ser verdadeiro: você está usando a delegação de eventos e está tendo um problema de desempenho. Basicamente, a delegação de eventos permite um tempo de inicialização de complexidade constante. No entanto, o preço de verificar se um evento é de interesse precisa ser pago para cada invocação desse evento. Isso pode ser caro, especialmente para eventos que ocorrem com frequência, como "mouseover" ou até mesmo "mousemove".
Problemas comuns e soluções
O que eu faço no $(document).ready leva muito tempo
Conselho pessoal do Malte: nunca faça nada em $(document).ready. Tente entregar o documento na forma final. OK, você pode registrar listeners de eventos, mas apenas usando o seletor de ID e/ou a delegação de eventos. Para eventos caros, como "mousemove", adie o registro até que eles sejam necessários (evento mouseover no elemento relevante).
Se você realmente precisar fazer algo, como uma solicitação Ajax para receber dados reais, mostre uma animação interessante. Você pode incluir a animação como um URI de dados se for um GIF animado ou algo parecido.
Desde que adicionei um filme em Flash à página, tudo ficou muito lento
Adicionar o Flash a uma página sempre vai deixar a renderização um pouco mais lenta, porque o layout final da janela precisa ser "negociado" entre o navegador e o plug-in do Flash. Quando não for possível evitar completamente o uso do Flash nas suas páginas, defina o parâmetro "wmode" do Flash como "window" (que é o padrão). Isso desativa a capacidade de combinar elementos HTML e Flash. Não será possível ver um elemento HTML que esteja acima do filme em Flash, e o filme em Flash não poderá ser transparente. Isso pode ser um inconveniente, mas vai melhorar muito seu desempenho. Por exemplo, confira como o youtube.com evita colocar camadas acima do player de vídeo principal.
Estou salvando itens no localStorage, e agora meu aplicativo está travando
A gravação no localStorage é uma operação síncrona que envolve a ativação do disco rígido. Nunca faça operações síncronas de "longa duração" ao realizar animações. Mova o acesso ao localStorage para um ponto no código em que você tenha certeza de que o usuário está inativo e que não há animações em andamento.
A criação de perfil aponta para um seletor jQuery muito lento
Primeiro, verifique se o seletor pode ser executado por meio de document.querySelectorAll. Você pode testar isso no Console JavaScript. Se houver uma exceção, reescreva o seletor para não usar nenhuma extensão especial do framework de JavaScript. Isso vai acelerar o seletor em navegadores mais recentes em uma ordem de magnitude.
Se isso não ajudar ou se você também quiser que o carregamento seja rápido em navegadores mais recentes, siga estas diretrizes:
- Seja o mais específico possível no lado direito do seletor.
- Use um nome de tag que você não usa com frequência como a parte mais à direita do seletor.
- Se nada ajudar, pense em reescrever as coisas para poder usar um seletor de ID.
Todas essas manipulações do DOM levam muito tempo
Um monte de inserções, remoções e atualizações de nós DOM pode ser muito lento. Isso geralmente pode ser otimizado gerando uma grande string de HTML e usando domNode.innerHTML = newHTML para substituir o conteúdo antigo. Isso pode ser muito ruim para a manutenção e pode criar links de memória no IE, então tome cuidado.
Outro problema comum é que o código de inicialização pode criar muito HTML. Por exemplo, um plug-in jQuery que transforma uma caixa de seleção em um monte de divs porque é isso que as pessoas de design queriam, ignorando as práticas recomendadas de UX. Se você realmente quer que sua página seja rápida, nunca faça isso. Em vez disso, envie toda a marcação do lado do servidor na forma final. Isso também tem muitos problemas, então pense bem se a velocidade vale a pena.
Ferramentas
- JSPerf: compare pequenos snippets de JavaScript
- Firebug: para criação de perfis no Firefox
- Ferramentas para desenvolvedores do Google Chrome (disponíveis como WebInspector no Safari)
- DOM Monster: para otimizar o desempenho do DOM
- DynaTrace Ajax Edition: para criação de perfis e otimizações de pintura no Internet Explorer