Text to binary (UTF-8)

Se você já passou horas depurando um problema de codificação de caracteres — aquela situação clássica onde `ã` vira `ã` ou onde um JSON que parece correto no editor misteriosamente quebra na API — provavelmente já se perguntou como os computadores realmente armazenam letras. A resposta é direta: eles não armazenam letras. Eles armazenam números. Cada tecla que você digita é mapeada para um número inteiro, que por sua vez é guardado na memória como uma sequência de bits — zeros e uns. O conceito remonta aos primeiros computadores elétricos: a ENIAC, concluída em 1945, operava com números decimais em hardware, mas o IBM 701 de 1952 e seus sucessores popularizaram a representação binária como padrão universal da computação. Desde então, tudo no computador — texto, imagens, sons, código executável — é, em última análise, uma sequência de bits.

O mapeamento entre letras e números foi padronizado pela primeira vez em 1963 com o ASCII (American Standard Code for Information Interchange), que atribuiu valores de 0 a 127 para letras do alfabeto latino, dígitos, pontuação e caracteres de controle. O `A` virou 65, o `a` virou 97, o espaço virou 32. Funcionava bem para o inglês, mas o mundo tem mais de 7 mil idiomas ativos. Nos anos seguintes surgiram inúmeras extensões regionais — o ISO 8859-1 para a Europa ocidental, o Windows-1252 da Microsoft, o Shift-JIS japonês — e a incompatibilidade entre elas criou o caos que o Unicode veio resolver. Em 1992, Ken Thompson e Rob Pike criaram o UTF-8: uma codificação de comprimento variável onde caracteres ASCII ocupam exatamente 1 byte e caracteres fora do ASCII usam 2 a 4 bytes. Hoje, mais de 98% das páginas web usam UTF-8.

Esta ferramenta converte cada byte UTF-8 do texto em sua representação binária de 8 bits e também decodifica de volta. Na prática, para textos em inglês com apenas caracteres ASCII, cada caractere produz exatamente um grupo de 8 bits. Para textos com acentos — como `ã` (U+00E3), que em UTF-8 é codificado como dois bytes: 0xC3 e 0xA3 — cada caractere pode produzir dois ou mais grupos. Isso é instrutivo e às vezes surpreendente: uma string de 5 letras com acentos pode virar 10 ou 15 bytes em binário. Os casos de uso reais incluem visualizar exatamente o que um dado texto representa em bytes para depurar problemas de serialização, criar exemplos didáticos para explicar encoding, resolver desafios de CTF (Capture The Flag) onde dados são transmitidos em binário, e simplesmente satisfazer a curiosidade de ver texto como a máquina o vê.

If you have ever spent hours debugging a character encoding issue — that classic situation where `ã` becomes `ã` or where a JSON that looks correct in the editor mysteriously breaks at the API — you have probably wondered how computers actually store letters. The answer is straightforward: they do not store letters. They store numbers. Every key you press is mapped to an integer, which in turn is stored in memory as a sequence of bits — zeros and ones. The concept goes back to the first electrical computers: the ENIAC, completed in 1945, operated with decimal numbers in hardware, but the IBM 701 of 1952 and its successors popularized binary representation as the universal standard of computing. Since then, everything in a computer — text, images, sounds, executable code — is ultimately a sequence of bits.

The mapping between letters and numbers was first standardized in 1963 with ASCII (American Standard Code for Information Interchange), which assigned values from 0 to 127 to Latin alphabet letters, digits, punctuation, and control characters. `A` became 65, `a` became 97, space became 32. It worked well for English, but the world has over 7,000 active languages. In the years that followed, countless regional extensions emerged — ISO 8859-1 for Western Europe, Microsoft's Windows-1252, Japan's Shift-JIS — and the incompatibilities among them created the chaos that Unicode was designed to fix. In 1992, Ken Thompson and Rob Pike created UTF-8: a variable-length encoding where ASCII characters occupy exactly 1 byte and characters outside ASCII use 2 to 4 bytes. Today, over 98% of web pages use UTF-8.

This tool converts each UTF-8 byte of the text into its 8-bit binary representation and also decodes back. In practice, for English-only text with ASCII characters, each character produces exactly one 8-bit group. For text with accented characters — like `ã` (U+00E3), which in UTF-8 is encoded as two bytes: 0xC3 and 0xA3 — each character can produce two or more groups. This is informative and sometimes surprising: a 5-letter string with accents can turn into 10 or 15 bytes in binary. Real use cases include visualizing exactly what a given text represents in bytes to debug serialization problems, creating educational examples to explain encoding, solving CTF (Capture The Flag) challenges where data is transmitted in binary, and simply satisfying the curiosity of seeing text the way the machine sees it.

Si alguna vez has pasado horas depurando un problema de codificación de caracteres — esa situación clásica donde `ã` se convierte en `ã` o donde un JSON que parece correcto en el editor misteriosamente falla en la API — probablemente te has preguntado cómo almacenan realmente las letras los ordenadores. La respuesta es directa: no almacenan letras. Almacenan números. Cada tecla que pulsas se asigna a un entero, que a su vez se guarda en la memoria como una secuencia de bits — ceros y unos. El concepto se remonta a los primeros ordenadores eléctricos: la ENIAC, terminada en 1945, operaba con números decimales en hardware, pero el IBM 701 de 1952 y sus sucesores popularizaron la representación binaria como estándar universal de la computación. Desde entonces, todo en un ordenador — texto, imágenes, sonidos, código ejecutable — es, en última instancia, una secuencia de bits.

La correspondencia entre letras y números se estandarizó por primera vez en 1963 con ASCII (American Standard Code for Information Interchange), que asignó valores del 0 al 127 a las letras del alfabeto latino, dígitos, puntuación y caracteres de control. La `A` se convirtió en 65, la `a` en 97, el espacio en 32. Funcionaba bien para el inglés, pero el mundo tiene más de 7.000 idiomas activos. En los años siguientes surgieron innumerables extensiones regionales — el ISO 8859-1 para Europa occidental, el Windows-1252 de Microsoft, el Shift-JIS japonés — y la incompatibilidad entre ellas creó el caos que Unicode vino a resolver. En 1992, Ken Thompson y Rob Pike crearon UTF-8: una codificación de longitud variable donde los caracteres ASCII ocupan exactamente 1 byte y los caracteres fuera del ASCII usan de 2 a 4 bytes. Hoy, más del 98% de las páginas web usan UTF-8.

Esta herramienta convierte cada byte UTF-8 del texto en su representación binaria de 8 bits y también decodifica en sentido inverso. En la práctica, para textos en inglés con solo caracteres ASCII, cada carácter produce exactamente un grupo de 8 bits. Para textos con caracteres acentuados — como `ã` (U+00E3), que en UTF-8 se codifica como dos bytes: 0xC3 y 0xA3 — cada carácter puede producir dos o más grupos. Esto resulta instructivo y a veces sorprendente: una cadena de 5 letras con acentos puede convertirse en 10 o 15 bytes en binario. Los casos de uso reales incluyen visualizar exactamente lo que un texto representa en bytes para depurar problemas de serialización, crear ejemplos didácticos para explicar la codificación, resolver desafíos de CTF (Capture The Flag) donde los datos se transmiten en binario, y simplemente satisfacer la curiosidad de ver el texto como lo ve la máquina.