ASCII Art Maker

Turn a photo into characters in your browser. This ASCII art generator uploads nothing.

Drop an image here

…or paste one with Ctrl/Cmd+V. Nothing is uploaded: the conversion runs in this tab.

There is no URL box, because a browser will not let a page read the pixels of an image it fetched from another site. Save the image and drop it here.

Mode
Size 80 columns
Advanced
Contrast 1
Brightness 0
Cell shape 0.5
Output — Waiting for an image 
 
 
   
       
     
 
 
  
 
 
 
How to use it
 
     
  1. 
Drop an image onto the box above, press Choose an image, or paste one
          with Ctrl/Cmd+V anywhere on the page. On a phone the
          button opens the photo library and a second one opens the camera.

    2.  
  2. Choose a mode. Shading is the default; the other five are for what shading cannot do.
    3.  
  3. 
Set the size. Press a preset, drag the slider, or type an exact column count in the box
          beside it. Everything re-renders as you go, because the pixels are already here.

    4.  
  4. Copy the text, download it as .txt, .html or .ans, or export a PNG.
    5.  
 
     
  •  Size sets how many columns of characters the picture is drawn in, and the
          rows follow from it. Five presets name the useful sizes — Tiny 24, Small 48, Medium 80,
          Large 140, Huge 240 — and the slider and the number box beside them take anything from
 10 to 300. The readout says the matrix and the
          character count together, so you know before you paste whether it will fit where it is
          going. Choosing a size is the section on what those numbers mean.

    •  
  •  Characters chooses the ramp: ten characters, seventy, four block shades,
          or between two and ninety-five of your own, densest first.

    •  
  •  Invert swaps dense for light, which is what a picture that is pale on a
          dark ground needs. Doing it twice gives back exactly the original.

    •  
  •  Mode switches between plain shading, dithering, edge detection, outline,
          braille and half-blocks. Color each character keeps each cell's own color
          instead of throwing it away.

    •  
  • 
Under Advanced are contrast, brightness, the shape of a character cell in
          the font you are pasting into, and the depth of the ANSI color codes. A control a mode
          does not use is hidden rather than grayed out, which is why the strip changes as you move
          along the mode buttons: dithering brings the serpentine switch, edges bring a threshold,
          outline brings Line sensitivity, and none of the three is on screen
          anywhere it would do nothing.

    •  
 
How it works
 

An ASCII generator has exactly one decision to make, and it makes it once per character
        cell: which character goes there. Everything else is arithmetic arranged around that
        decision.

 

The browser decodes the file and scales the image so its longest side is at most 2,048
        pixels — enough for any column count on offer, and small enough that a phone finishes. That
        working image is divided into a grid of cells and each cell's pixels are averaged. The
        average is reduced to one brightness with the Rec. 709 luma weights, on the gamma-encoded
        values exactly as they came out of the file:

 
Y′ = 0.2126R + 0.7152G + 0.0722B
 

Green carries nearly three quarters of that sum, which is why a red mark on black comes out
        darker than it looks to you, and why turning a photo monochrome by averaging the three
        channels never looks right. The brightness then picks a character: the ramp is quantized
        into n equal bins and the index is floor(Y′ × n ÷ 256) — 256
        rather than 255, which is what makes the bins the same width and keeps pure white inside the
        last one. The character written into the cell is ramp[idx].

 

All of it runs in a Web Worker; the main thread only decodes the file and draws the result,
        which is why dragging the size slider does not stall the page. Files over 25 MB and images
        over 80 megapixels are refused with a sentence saying why, rather than with a spinner that
        never stops.

 

One consequence is worth stating because it saves people work: the size of your
        photo does not change the result. The converter samples one cell at a time, and at
        eighty columns it wants eighty averages across whatever it has to average them from. A
        forty-megapixel photo and a 640×480 crop of the same scene are both reduced to the same
        eighty-column grid before a single character is chosen. A bigger file costs decode time and
        nothing else, and upscaling an image before converting it achieves nothing at all.

 

There is a floor under that, and it is the only thing the size of the original decides: a
        cell needs a pixel to average, so a picture with fewer pixels across than the columns you
        asked for is the one case where a larger original would genuinely have helped. A photograph
        never runs into it. A 64-pixel icon does, which is why converting a logo
starts with exporting it larger.

 
Choosing a size
 

The output is a matrix of characters, and its size is the one thing you actually choose. You
        choose it in columns. Everything else — the row count, the character count, whether the
        piece survives a paste — follows from that number, which is why the control offers it three
        ways: five presets that say what the useful sizes are, a slider for a sweep, and a box to
        type an exact width into. All three carry the same value, so moving one moves the others.

 

The rows are not yours to set, and there should be no control for them. A character cell is
        about twice as tall as it is wide — a 0.6em advance under a 1.2em line height, which is what
        you get in a terminal, a code block and a chat message — so the row count is derived:

 
rows = max(1, round(height × columns × 0.5 / width))
 

Eighty columns of a 640×480 photo is thirty rows, not
        sixty. Ignoring that factor is what makes ASCII output look stretched, and if rows were a
        separate control you would have to keep them in step with the columns by hand, where every
        value except the right one squashes or stretches the picture. The 0.5 is exposed under
Advanced as Cell shape, between 0.4 and 0.6, for the case
        where you know the font at the other end is narrower or wider than that.

 
What each preset is for
 

The rows and characters below are for that same 640×480
photograph, worked out by the same two functions the converter uses. A taller photograph
        gives more rows at every width and a wider one fewer; the ratio between the sizes does not
        change.

 
 
  
 Preset Columns Rows Characters What it is for 
   
 Tiny 24 9 224 a chat signature, a forum footer, an avatar-sized mark 
 Small 48 18 881 a phone screen, a Discord message with room left over 
 Medium 80 30 2,429 a terminal, a code block, a README — the default 
 Large 140 53 7,472 a desktop window, a photograph with detail worth keeping 
 Huge 240 90 21,689 a wall of text you control: a page, a print, a screensaver 
  
 
 

A 24-column piece is a silhouette and nothing more: at that size a cat is an
        outline with two eyes in it, and that is the point — it fits in a signature, a footer or a
        line of chat without wrapping, and it stays legible on a phone. A 240-column
        piece is a different object altogether. It holds nearly a hundred times as many characters,
        keeps the detail a photograph actually has, and will wrap into nonsense anywhere narrower than
        about 240 characters — which is most places. Wide output is for somewhere you
        control: a full-screen terminal, a file, an image export, a printed page.

 

The slider runs from 10 to 300 columns, and so does the
        box beside it. Ten is genuinely usable for a bold shape and is what “very small” means to
        someone pasting into a signature. Braille stops at 200 instead, because
        it takes two samples across every column, and its Huge preset is disabled with a note saying
        so rather than quietly giving you something narrower than the button promised. A preset
        wider than the image itself is disabled for the same reason: a grid cannot be wider than the
        pixels it samples.

 
The character count, and why it is on the readout
 

The readout beside the control says the matrix and the character count together —
80 × 30 — 2,429 characters. The
        second number is the one nobody else shows and the one that decides where a piece can go.

 

It counts exactly what Copy puts on your clipboard: every character in the
        grid, plus the 29 newlines holding the 30 rows apart. There is
        no trailing newline, so the copy and the .txt download are the same bytes.
        Eighty columns of a photograph is 2,429 characters, which is already over
        the 2,000 a Discord message allows — the same picture at 48 columns is
 881 and fits with room to spare, and at 24 columns it
        is 224, which is small enough for a forum signature. Working that out
        from the column count alone is arithmetic nobody should have to do in their head while
        deciding whether to press Copy.

 

One caveat, and it is the usual one: the count is characters, not bytes. Braille and the
        block ramp are outside ASCII, so each of those characters is three bytes of UTF-8 rather
        than one. Wherever the limit is stated in characters — Discord, a signature, a profile
        field — the number on the readout is the number that matters; where it is stated in bytes,
        multiply.

 

Type into the box and the value is taken when you leave it or press Enter, not as you type,
        so “1” on the way to “150” is not read as a request for one column. Anything outside the
        range is clamped and the tool says what it did and why, naming the number you asked for.
        Nothing you can type into it produces a broken render.

 
Image to ASCII art, mode by mode
 

Whether you start from an image, a photo off your phone or a picture somebody sent you, the
        pipeline above is the same one. What changes is which of the six modes reads the brightness
        once it has been measured, and they differ more than their names suggest. Each is below with
        real output under it — generated when this site was built, by the same code the converter
        runs, so selecting a block and copying it works like copying any other writing on the page.
        The last one is the exception: color and half-blocks cannot be shown in plain text at all,
        which is the whole of what that section is about.

 

The subjects are not all one drawing. There is no piece here rendered six ways, and
        converting one subject badly six times would show less than showing each mode on something
        that suits it. They are all the same kind of drawing, though — line drawings made
        with a single pen — so the difference between two blocks really is the mode. Under each one
        are the settings that produced it.

 
Shading — one character per cell
 

The default mode, and the one whose output goes anywhere, because what comes out is plain
        ASCII. Each cell gets a single character from a ramp written densest first.

 

The standard ramp is ten characters, @%#*+=-:. , dense to light. It ends
        in a space, and that space is the character for the lightest bin rather than padding. The
        seventy-character ramp gives finer steps, but it is only genuinely sharper in a font whose
        glyphs really do differ in weight; in many monospace faces half of those seventy read as the
        same shade and you have bought noise. Or type your own — between two and ninety-five
        characters, densest first. Shading is the mode to try first and the one to come back to when
        something cleverer has turned a photograph into mush.

 
 
  
 
 Shading, the ten-character ramp 46 columns × 25 rows 
 
 

Four block shades are the third ramp — █ ▓ ▒ ░ and a space — and
        they behave differently enough to be worth a block of their own. A block fills its whole
        cell, so a solid area comes out solid rather than as a texture of asterisks; the cost is a
        font with block coverage, which is commoner than braille coverage and not universal.
Invert is the switch beside the ramp and the piece below needs it: it takes
ramp[n − 1 − idx] instead of ramp[idx], which is what a pale
        subject on a dark ground wants — without it the night sky becomes the dense characters and
        the bolt comes out blank.

 

Inverting is applied after quantization, so it is a symmetric flip of the index rather than
        a change to the picture: invert twice and you have exactly what you started with, and for an
opaque image no brightness is changed at all, which is why the stipple in dither
        mode is identical — the same cells, with the characters standing in them exchanged. It also
        flips the ground a transparent PNG is composited over, from white to black, so a logo with
        no background reads correctly either way; and because that ground is what every partly
        transparent cell is mixed with, a transparent image's brightness, and so its stipple, really
        does move.

 
 
  
 
 The block ramp, inverted 36 columns × 24 rows 
 
 
Dithering — the rounding error pushed into its neighbors
 

Quantizing to ten characters throws most of a photograph away: a smooth sky becomes three or
        four flat bands with visible steps between them. Floyd–Steinberg dithering keeps the error
        instead of dropping it. Each cell is rounded to the nearest ramp level, and the difference
        between what it should have been and what it got is pushed into four cells that have not been
        visited yet — 7/16 to the right, 3/16 below-left, 5/16 below, 1/16 below-right. Error that
        falls off the edge of the grid is dropped rather than shared out again; that is the classic
        algorithm, and the first row and the last column depend on it. What you see is a stipple that
        averages to the right tone, so gradients hold together at ten characters where they would
        otherwise band.

 

It earns its place on photographs and it ruins line art. A drawing made of flat areas and
        hard edges has no tonal detail for the error to encode, so the error simply wanders: flat
        regions break into speckle and every edge picks up a fringe of stray characters. If the
        source is a logo, an icon, or anything drawn rather than photographed, leave dithering off
        and use shading or outline.

 
 Serpentine scan reverses the direction of every other row and mirrors the
        kernel with it. Scanning every row left to right leaves a faint diagonal worm on smooth
        gradients — a repeating pattern drifting down and to the right. Serpentine removes it, and
        costs nothing.

 
 
  
 
 Floyd–Steinberg dithering, the seventy-character ramp 46 columns × 26 rows 
 
 
Edges — Sobel on the character grid, not on the pixels
 

Edge mode ignores tone and looks for boundaries. A Sobel operator measures how fast
        brightness changes at each cell and in which direction. Cells whose gradient magnitude clears
        the threshold become one of four characters chosen by the angle of the edge running through them
        — |, /, - or \ — and everything else
        becomes a space. The Sobel pass runs over the character grid, not over the source pixels,
        which is what makes the diagonals come out at the right angle: the grid is anisotropic, a
        cell is twice as tall as it is wide, and / and \ are drawn inside
        those same cells. Measured in pixel space, every diagonal leans the wrong way by the time it
        is written into one.

 
 What it finds is the boundary of a region, and that is not the same thing as a
        line. A photograph has regions, so edges is a good description of one: the horizon,
        the edge of a face, the frame of a window. A drawing has strokes, and a stroke is a
        thin region with two boundaries, one down each side — so a pen any wider than a cell comes
        back as two parallel contours with a gap between them, and a shape filled with ink comes
        back as its outline twice over. It is a rubbing of the drawing rather than the drawing.

 

The snowflake below is kept in this mode precisely so that the doubling is visible somewhere
        on the site. Its arms come back twice — \// beside \\/, a line of
        dashes with a second line of dashes under it — because Sobel found the left side of every arm
        and the right side of it and had no way to know they were the same arm. Nothing is
        malfunctioning; edge mode is being asked to keep boundaries in a picture made of lines, and
outline below is the mode for that instead.

 

Where edges earns its place is the case outline cannot touch: a photograph, a scan, a
        rendered image — a picture with no strokes in it at all, where a boundary is the only kind
        of line there is. Edge threshold runs from 0 to 1,020, where 1,020 is a full
        black-to-white step across a single cell; the default of 255 is a quarter of that. Lower it
        to pick up soft boundaries, raise it until only the real ones survive.
Draw edges over the shading keeps the ramp underneath instead of blanking
        it, which is worth trying on a photograph and rarely worth it on a drawing.

 
 
  
 
 Edge mode, the default threshold of 255 56 columns × 28 rows 
 
 
Outline — one character per stroke
 

Outline is the only mode here that never asks how dark a cell is. It asks two other
        questions instead. Is there ink in this cell? And if there is, which way does it run? The
        first is a threshold on how much of the cell the drawing blacked in — about a sixth of it
        by default. The second is answered by the eight cells around it: lit above and below gives
|, lit left and right gives - or _, and the two
        diagonals give / and \. Where ink leaves the cell in all four
        directions the character is +, because no single stroke describes a crossing
        and a plus sign is the mark that connects on all four sides. A lit cell with nothing beside
        it is a .. That is the entire alphabet — - _ | / \ . + and a
        space — and the character in a cell is therefore a statement about the direction of the
        line passing through it rather than about its tone.

 

Which is why one stroke comes back as one stroke. There is no differentiation anywhere in
        this mode, so there is no second contour to find: a pen a cell wide is a single column of
|, where edge mode would return the left side of it and the right side of it
        and a hole down the middle. Set the house below beside the snowflake above and that is the
        whole of the difference: both sources are single-pen line drawings, both went through this
        same pipeline, and only the mode changed.

 

The choice between _ and - is the small detail that makes the
        output look drawn rather than assembled, and it is worth knowing about because it is the
        one place the converter looks inside a cell. In outline mode each cell is sampled
        four times down its height, and the character is picked by where the ink actually sits: a
        horizontal run lying along the bottom of its cells gets _, which is drawn on
        the baseline, and one crossing the middle gets -, which is drawn at mid height.
        Get that backwards and every horizontal detaches from the vertical it is supposed to meet,
        and a drawing of a box turns into a staircase of floating underscores. Get it right and the
        corners join.

 
 Line sensitivity is the only control the mode has, and it runs the opposite
        way to Edge threshold: it is how little ink a cell needs before it counts as
        part of a line, so turning it up draws more. Turn it up far enough and the soft halo
        either side of every stroke lights as well, and each line comes back two characters wide —
        the doubling this mode exists to avoid, arriving by another road. Turn it down and thin
        strokes drop out, a whole line at a time. The default is in the quiet part between the two.
        There is no ramp here and the ramp picker is hidden, because nothing in this mode is
        quantized.

 

What suits it is line art: a monoline drawing, a logo built out of strokes, a wireframe, a
        diagram, a floor plan, a map, an outlined wordmark — anything whose meaning is already
        carried by its lines. What does not suit it is a photograph, which has no lines in it to
        find, only tone, and comes back as speckle at every setting. A filled silhouette is the case
        in between, and it fails in an instructive way: outline returns its contour with the whole
        inside hatched in plus signs, which is the mode correctly reporting that ink leaves every
        interior cell in all four directions. If the mark is solid, shading with the block ramp is
        the mode for it. If it is drawn, this is.

 
 
  
 
 Outline mode, the default line sensitivity 58 columns × 21 rows 
 
 
Braille — eight dots inside one character
 

A braille cell is a 2×4 grid of dots, and Unicode gives all 256 combinations of those eight
        dots a code point of their own: U+2800 plus the dot bits. So the converter samples each cell
        eight times instead of once — twice across, four times down — and at the same column count
        it resolves twice the horizontal detail of a shading grid and four times the vertical. Thin
        lines, a bird's legs and small text inside a photograph survive it where a ramp loses them.
        It is what makes this a braille art generator as much as an ASCII one.

 

Three things to know first. It is not ASCII: it needs a font covering U+2800–U+28FF, so it
        pastes cleanly into a terminal, into Discord and into most code editors, and into a font
        without braille coverage it becomes a row of empty boxes — Consolas, the default monospace on
        Windows, has no braille coverage at all, which is why the PNG export ships its own. The blank
        cell is U+2800, the braille blank, not a space: it looks like nothing and it is not nothing,
        which is what stops an editor that trims trailing whitespace from collapsing the right-hand
        edge of the grid. And those two samples across have to come from somewhere: braille needs an
        image at least twice as wide as the column count you ask for, and it is the one mode whose
        ceiling is 200 columns rather than 300.

 

The dots are binarized by the same Floyd–Steinberg pass by default, which is where braille
        output gets its texture. Turning Dither the dots off substitutes a plain
        mid-gray threshold: harder, flatter, and usually better on something that was black and white
        to begin with.

 
 
  
 
 Braille, dithered dots 56 columns × 18 rows 
 
 
Color and half-blocks, and what they cost
 

There is no block of output for these two, and the reason is the point of the section: plain
        text cannot carry either of them, which is exactly what makes them a trade rather than a
        free improvement.

 
 Color each character keeps the average color of every cell alongside the
        character. The character is still chosen by brightness; the color is carried, not used to
        choose, which is why a colored render and a plain one have exactly the same characters in
        them. There are three ways out. Copy in color gives HTML — one
<span> per run of identically colored cells, so a flat background is one
        span and not four hundred. Download .ans gives ANSI escape codes, 24-bit by
        default or the 256-color cube for older terminals, under Advanced. And
Half-block is a mode rather than a switch: every character is
▀, U+2580, with the top half painted in the foreground color and
        the bottom half in the background, so one character carries two pixels and the vertical
        resolution doubles.

 

What color costs you is plain text. The characters still exist, but the color lives in
        markup or in escape codes, so a .txt export of a colored render is the uncolored render,
        and a .txt export of half-block is a solid block of ▀ — the tool
        says so rather than letting you find out later. Colored HTML is also declined above twenty
        thousand cells, where the span count stops being something a browser enjoys; PNG and ANSI
        still work at that size.

  

A logo is the easiest thing here to convert and the easiest to ruin. The grid is coarse: at
        sixty columns one cell covers a real piece of the mark, and everything inside a cell is
        averaged into one character. What survives is what is still legible when you squint — bold
        closed shapes, two or three colors, honest contrast between the mark and its ground.
        Gradients, drop shadows and small type do not survive at all, because each of them lands
        inside a cell and averages away. A thin outline is the one item on that list that can be
        rescued, and rescuing it is what the next paragraph is about.

 

Which mode to use follows from one question: is the mark drawn or is it
filled? A monoline mark — a wireframe, a pictogram, a logo built out of strokes,
        an outlined wordmark — wants outline, which is the one that produces
        line art rather than a picture of it. A mark made of solid areas — a filled silhouette, a
        heavy solid wordmark — wants shading with the block ramp instead, which
        fills a solid area solidly; step the size up, Small then Medium then Large, until the shape
        reads. If it is pale on a dark ground, turn invert on, or the background becomes the ink.
        Put a filled mark through outline and you get its contour with the inside hatched in plus
        signs; put a drawn mark through edges and every stroke comes back twice.
        Neither is a malfunction, and both are the wrong question asked of the picture.

 

Export the logo large before you bring it here. This is the one place the size of the
        original matters: the conversion samples the picture rather than reading it, so a 64-pixel
        favicon has nothing left to average by the time it reaches a
        hundred cells; a few hundred pixels across the mark is plenty, and more than that costs only
        decode time. Flatten it onto a background you have chosen, too — a transparent PNG is
        composited over white, or over black when invert is on, and a mark designed for one of those
        can vanish into the other.

 

A wordmark is the hard case, because letterforms are the first thing a coarse grid loses.
        There is no type tool here to fall back on: this site converts pictures, so a wordmark has
        to arrive as one. Set it large and heavy, keep it to a word or two, and give it a Large or
        Huge size rather than the default — at 80 columns a five-letter word has sixteen cells per
        letter, and at 240 it has nearly fifty, which is the difference between a smudge and
        something readable. If you can set the word in an outlined face rather than a
        solid one, do: outline mode then keeps each stem as one character wide instead of one blob
        wide, and the counters inside an A, an R or a C stay open. That is not a claim about
        somebody else's type — it is what happened to the word at the top of this page, which is
        set in a stencil alphabet drawn for this repository and converted in outline mode by the
        same pipeline the tool runs.

 
 
  
 
 A monoline mark, outline mode, no ramp at all 56 columns × 18 rows 
 
 
Why nothing is uploaded
 

Converting an image is arithmetic over an array of pixels, and your browser is already
        holding the array. There is no reason to send it anywhere, so this site does not. That is
        the whole of the privacy claim, and it is a fact about where the code runs rather than a
        promise about how carefully a server is looked after.

 

Everything else follows from it. There is no queue and no spinner waiting on somebody's
        machine, so moving a slider re-renders at once. There is no account, because there is nothing
        to attach one to; no free tier and no paid tier, and no watermark on anything that comes out.
        Safari decodes the HEIC files an iPhone produces, so a photo from the camera roll opens
        without a conversion step first.

 

It is also what makes the controls worth having. Dithering, edge detection, outline, braille
        and color are settings you want to try and reject within a second or two, and a product that
        sends every change to a server and waits for the answer finds them awkward to offer live.
        Here they are a click, and the picture has already changed.

 
A worked example
 

Every piece above was rendered at a width that suited it. This last one is here to show the
        one thing none of them can: it is the only square source on the page. It came out of the
        converter above at forty columns in outline mode, with nothing else touched, and forty
        columns came back as eighteen rows rather than forty — the cell-shape factor doing its work
        on a drawing that started out very nearly square. The source is one closed curve and no
        fill, so every character in the result is a piece of that curve and everything else is a
        space, which is also why it is the shortest thing on this page to paste.

 
 
  
 
 Outline mode, one closed curve 40 columns × 18 rows 
 
 
 
 
Where else to go
 
“ASCII converter” means something else as well, and the other reading has a page: the codes behind the characters themselves, decimal, hexadecimal, octal and binary, with the whole printable range from 32 to 126 tabulated and a box that converts either way. That is the ASCII converter, and it has nothing to do with pictures.
If you want to know who made this and why it has no accounts, about is short and answers both. The type, the stencil alphabet in the mastheads and the one font the PNG export carries are listed with their licenses on credits.
What the site measures is four events and a page view, none of which can carry your image, and the privacy page names each one in a table rather than describing them in general terms.
 
 
 
Questions
 
 How do I convert a photo to ASCII art? 
Drop the photo on the box at the top of this page, choose a mode, and set the size — press one of the five presets, drag the slider, or type a column count. Then copy the text, or download it as .txt, .html or .ans, or export a PNG. There is no sign-in and no upload step, and the result appears within a moment of the file being read.
 
 Does this ASCII art creator need an account? 
No. There is no sign-in, no free tier and no paid tier, and nothing it produces carries a watermark. Shading, dithering, edges, outline, braille, color and every size are all the same free thing, and there is no cap on how many images you convert, because each one costs this site nothing — the work happens on your computer, not ours. The limits that do exist are technical: a 25 MB file, eighty megapixels once decoded, a working copy capped at 2048 pixels on its longest side, and never more columns than the image has pixels across.
 
 Is my image uploaded anywhere? 
No. Your browser decodes the file, a background worker measures each character cell and picks a character for it, and the result is drawn on the page you are already on. The image never leaves your machine, which is also why the first conversion is as quick as the tenth: there is no queue in front of it. What the site does record — page views and a short list of tool events, none of which carries your image, its file name or its dimensions — is set out in full on the privacy page.
 
 Which mode should I use? 
Photographs: shading first, then dithering if a sky or a gradient is banding, and edges if what you want is the boundaries rather than the tone. Line art, icons, diagrams and anything drawn in strokes: outline, which returns one character per stroke instead of one per side of it — or the block ramp where the mark is solid areas rather than lines. Anything thin — wires, legs, small text inside the picture: braille. Whichever you pick, turn invert on if the subject is pale on a dark ground, and if the result is nearly right but mushy, the answer is usually a larger size rather than a different mode.
 
 What size should the output be? 
Five presets say what the range is for: Tiny at 24 columns for a chat signature, Small at 48, Medium at 80 — the width of a terminal, a code block and most chat windows, and the right first try — Large at 140, and Huge at 240 for something detailed on a screen you control. The slider and the number box beside them take any width from 10 to 300 — or 10 to 200 in braille, which takes two samples per column, so the Huge preset is disabled there. Only the columns are yours to set: the rows are derived, because a character cell is about twice as tall as it is wide, so eighty columns of a 640×480 photo comes back as thirty rows rather than sixty. The readout states both, and the character count with them — 80 × 30 is 2,429 characters, which is what decides whether a piece fits a 2,000-character Discord message.
 
 What is braille art, and where will it paste? 
Braille art uses the Unicode braille block instead of ASCII: each character is a 2×4 grid of dots, so it carries eight samples where a letter carries one. It pastes cleanly into a terminal, into Discord and into most code editors, and not at all into a font without braille coverage — there you get a row of empty boxes. The braille section has the rest.
 
 Why does my picture come out darker than it looks? 
Brightness here is Rec. 709 luma, Y′ = 0.2126R + 0.7152G + 0.0722B, roughly how an eye weighs the three channels. Green carries most of it and red very little, so a saturated red mark on black converts almost as dark as the black around it. Raise Brightness or Contrast under Advanced.
 
 Can it open a photo taken on an iPhone? 
In Safari, yes: it decodes HEIC natively, so a picture straight off the camera roll can be dropped in without converting it first. Other browsers cannot decode HEIC at all, and there the tool says so — This browser cannot open HEIC. Safari can, or export the photo as JPEG first. — rather than sitting on a spinner. PNG, JPEG, GIF, WebP and BMP work everywhere.
 
 Where can I paste ASCII art without it falling apart? 
Anywhere the font is monospaced: a terminal, a code block, a Discord message inside triple backticks, a README, plain-text email. In a proportional font every row comes out a different width and the picture collapses. Braille output asks for one thing more than a monospaced font — one that actually draws the Braille Patterns block, which not every system font does.
 
 Is there an ASCII art app, or does this only work online? 
There is no app and no plan for one: this is a web page, with nothing to install and nothing to sign into. “Online” is doing something odd in the question, though. You reach the page over the internet, but the conversion is not online in the sense people usually mean — the image is not sent somewhere, queued, converted and sent back. Once the page has loaded you can turn the Wi-Fi off and it still works, because the code doing the arithmetic is already in the tab.
 
 Can it turn a word I type into ASCII art? 
Not from typed text — this converts pictures, and a picture is what it needs. If you want a word, make an image of it first: set the word large in whatever you have to hand, export it as a PNG a few hundred pixels tall, and drop that in. The block ramp fills a heavy face solidly, and outline mode is the one to use if you set the word in an outlined face rather than a solid one. What you will not get that way is the trick of letters drawn character by character for the grid, so keep the word short and the type bold, and give it plenty of columns.
 
 
   
  
   
 
Privacy choices
 

Nothing you drop on this site is uploaded. Images and text are decoded and converted in this
      tab and never leave it, whichever choice you make here.

 

What this controls is measurement: anonymous counts of which pages are opened and which
      conversion modes are used, so the tool can be made better at the things people actually do.
      No names, no addresses, and never your image or your text.