ansilove.org No paid content found

An artpack is a packaged collection of text-mode artwork—mostly ANSI and ASCII pieces—released by a group or artist, usually on a monthly schedule or as a single themed drop. If you have an artpack and want to see or convert its contents, you open the individual files inside it with a text-art viewer or convert them to images with a tool like Ansilove. The catch is that many files carry SAUCE metadata and assume a specific font (often CP437), so the right viewer or converter settings matter for correct display.

What an artpack actually contains

An artpack is not one file format. It is a container—historically a ZIP or similar archive—holding many small text-art files plus supporting material. Typical contents:

• .ans files — ANSI art. These use escape sequences to set colors and cursor positions, so they only look right when rendered by something that interprets those codes.
• .asc files — ASCII art. Plain characters, no color codes, viewable in any text editor but designed for a fixed-width font.
• .pcb files — PCBoard format, associated with the PCBoard BBS software. These are a distinct text-mode format, not plain ANSI.
• SAUCE metadata — a trailing record attached to many artscene files that describes the file: title, author, group, and often the font or display mode expected. Tools read this to render correctly.
• Readme/nfo files — release notes, member lists, and credits that accompany the art.

The name "artpack" comes from the artscene, the community of artists who made text-mode graphics for bulletin board systems (BBSes) and later distributed their work in these packs.

Why they exist and how they were distributed

Artpacks solved a distribution problem. Before the web, artscene groups needed a way to ship a whole month's worth of work to BBSes and rival groups in one transfer. Packing the files into a single archive made that practical.

Two common release patterns:

• Monthly packs — a group releases everything its members made that month.
• Group or themed packs — a curated set around a theme, an event, or a specific artist.

This is why artpacks are a historical record: they preserve text art that would otherwise exist only as scattered files on dead BBSes. Archives like Textfiles.com collect them, and projects such as Ansilove list artpack-related collections among their users.

How to open or convert an artpack

The workflow is the same whether you just want to look or want to produce images.

1. Unpack the archive. Extract the artpack to a folder. You will get many individual .ans, .asc, .pcb, and text files.
2. Choose a viewer or converter. For viewing, any ANSI/ASCII-aware viewer works. For conversion to PNG, Ansilove is a dedicated ANSI-to-PNG converter that also handles artscene-related formats.
3. Convert a file. With Ansilove, you point it at an input file and it writes a PNG. The input is the text-art file; the action is rendering it through a font and color table; the expected result is a PNG that matches how the art looked in a text-mode terminal.
4. Check the output against the original. If colors or characters look wrong, the issue is usually font or encoding, not the file.

Because artpacks contain many files, batch conversion is the practical approach—run the converter over the whole extracted folder rather than one file at a time.

Common problems and how to fix them

Most display errors trace back to two things: SAUCE metadata and font/encoding.

Ansilove's own changelog shows how real these issues are. Recent releases fixed "Amiga Topaz 1" font selection from SAUCE metadata, corrected a font table entry count so topaz500+ became reachable, and added the Spleen 8x16 font with full CP437 support. In other words, correct rendering depends on the tool reading SAUCE and having the right font data—so if an artpack file looks broken, updating the converter or changing the font is often the fix, not editing the file.

Practical takeaways

• An artpack is an archive of ANSI/ASCII/PCBoard text art, usually released monthly or by group.
• The files inside are not interchangeable: .ans, .asc, and .pcb need format-aware handling.
• SAUCE metadata tells viewers and converters how to render a file—respect it.
• For conversion to PNG, use a tool with broad font and CP437 support, and batch-process the extracted folder.
• When output looks wrong, suspect font selection or SAUCE handling before assuming the file is corrupt.

Text mode is a display mode where the screen is treated as a grid of fixed-size character cells rather than a canvas of individually addressable pixels. Each cell holds one character plus attributes such as foreground color, background color, and sometimes bold or blink. ANSI art, ASCII art, and the BBS "artscene" all grew up inside this model, which is why their files store character codes and color commands instead of pixel data. To view them faithfully you need a renderer that understands the original code page and font; to share them as images you convert them, for example with Ansilove, which turns ANSI and related artscene formats into PNG.

Why text mode produced a distinct kind of art

In text mode the smallest unit you can draw is a character cell. You cannot place a dot halfway between two cells, and you cannot use an arbitrary color — you pick from the palette the hardware or terminal offers. That constraint shaped the art:

• Resolution is measured in columns and rows, not pixels. A classic DOS text screen is 80 columns by 25 rows; a BBS might use 80x24 or other sizes.
• Color comes from attributes, not from per-pixel values. A cell's foreground and background are chosen from a limited set (16 colors in the classic PC palette).
• Shading and gradients are faked by choosing characters with different densities (░, ▒, ▓, █) and by mixing foreground/background colors.

This is why text-mode art looks blocky and character-driven, and why the same file can look different depending on the font and palette used to render it.

How text-mode art encodes what you see

A text-mode art file is essentially a stream of instructions to a terminal. Three things are being encoded:

1. Characters. Each glyph is a code point in a code page. The IBM PC world standardized on CP437, which includes box-drawing characters, block elements, and shading characters that ANSI art relies on heavily. If a viewer interprets the bytes as a different code page, those characters turn into the wrong symbols.

2. Colors and attributes. ANSI escape sequences (the "ANSI" in ANSI art) set foreground and background colors and toggle attributes. A sequence like an escape code followed by parameters tells the terminal "from here, draw in this color."

3. Cursor position. Escape sequences also move the cursor to a specific row and column, so the file can paint non-sequential parts of the screen. This is what separates ANSI art from plain ASCII art: ANSI art uses positioning and color, while ASCII art is typically just characters in reading order.

Formats you will encounter

Fonts matter as much as the file. Ansilove's release history shows ongoing work here: Spleen 8x16 was added with full CP437 support, and later synced to Spleen 2.0.0 (which swapped the arrows at positions 1A and 1B). A font change at that level can visibly alter how a piece renders.

Viewing text-mode art vs. converting it to an image

There are two different goals, and they need different tools.

Viewing in a terminal. A modern terminal is not a DOS text-mode screen. It can usually display the characters, but it may not honor the exact palette, the original font, or the original screen dimensions. You get something recognizable, not necessarily pixel-faithful.

Converting to PNG. This is what Ansilove is built for: "a set of tools to convert ANSi and artscene related file formats into PNG images." Conversion freezes the art into an image using a chosen font and palette, so it looks the same everywhere. That is the practical route when you want to archive, post, or compare pieces.

A typical conversion flow looks like this:

1. Get the file in its original format (.ans, XBin, PCBoard, etc.).
2. Run the converter on it, specifying output and any font/palette options you need.
3. Check the result against how the piece is "supposed" to look — especially if it uses a non-default font or a code page other than CP437.
4. Adjust the font or rendering options if characters or colors come out wrong.

The expected result is a PNG that reproduces the character grid, colors, and positioning of the original. The common failure is a mismatch between the font/code page the art was made for and the one the converter used.

Common problems when rendering text-mode art

• Wrong code page. Bytes meant as CP437 render as the wrong glyphs. Box-drawing and shading characters are the first to break.
• Missing or wrong font. If the art was made for a specific font (Amiga Topaz, Spleen 8x16, a custom XBin font), the default font will not match. XBin can carry its own font data, which is why it needs special handling.
• SAUCE metadata ignored. SAUCE records information about a piece, including font. Ansilove's changelog notes a fix for selecting the "Amiga Topaz 1" font from SAUCE metadata — meaning if the metadata is not read, the wrong font is used.
• Palette differences. The same color index can map to different RGB values depending on the renderer, so colors shift.
• Screen size assumptions. Art drawn for one column/row count can wrap or clip if the renderer assumes another.

Practical takeaways

• Text mode = character cells + attributes, not pixels. That single fact explains almost everything about how ANSI and ASCII art look and behave.
• ANSI art ≠ ASCII art. ANSI art uses color and cursor positioning; ASCII art is plain characters.
• The file alone is not the whole picture. Code page and font are part of the artwork, which is why formats like XBin embed fonts and why SAUCE metadata matters.
• To preserve or share a piece, convert it to PNG with a tool that respects the original font and code page, and verify the output rather than assuming the default settings are correct.

If your goal is just to read the art, a terminal viewer is fine. If your goal is fidelity — archiving, posting, or comparing against the original — convert to an image and check the font and code page first.

ASCII art is an image or design built entirely from standard keyboard characters — letters, numbers, punctuation, and symbols — arranged so the shape reads as a picture or decorative text. It differs from emoji, which are single Unicode pictographs, and from kaomoji, which are Japanese-style text emoticons like (・ᴗ・)♡. Use ASCII art when you need visuals in a plain-text space where emoji may not render, such as code comments, terminal output, or older forums. Use emoji or kaomoji instead when you want a quick, colorful symbol that displays reliably on modern apps.

ASCII art vs. emoji vs. kaomoji

The key distinction: emoji are characters that carry their own image, while ASCII art and kaomoji are arrangements of ordinary characters that only look like something when the spacing holds.

Common types of ASCII art

• One-line text art — small faces and icons that fit inline, e.g. (^_^), (T_T), (¬_¬).
• Multi-line pictures — larger images built across several rows, such as animals, logos, or objects.
• Decorative borders and dividers — lines like ====, ~~~~, or *~*~*~* used to separate sections of text.
• Text banners — words spelled out in large block letters made from characters.

Where ASCII art works best

ASCII art shines in environments that strip out or don't support rich formatting:

• Code comments and README files
• Terminal and command-line output
• Plain-text emails and older forum posts
• Signatures and bios where you want a retro or tech look

For Instagram, TikTok, or WhatsApp, emoji and kaomoji usually display more reliably and colorfully. CuteEmoji.AI, for instance, groups kaomoji and aesthetic symbols alongside its emoji collections for exactly these social use cases.

How to copy or make ASCII art

To copy ready-made art:

1. Find the piece you want (many sites, including CuteEmoji.AI, list ASCII art and kaomoji alongside emoji).
2. Select the characters exactly as shown.
3. Paste into your target field and check that the alignment still looks right.

To make simple art yourself:

1. Choose a fixed-width (monospace) font so every character takes equal space.
2. Sketch your shape on a grid, one character per cell.
3. Use characters that suggest the shape — / and \ for diagonals, _ and - for horizontals, O or 0 for circles.
4. Paste into your destination and adjust spacing if it shifts.

Expected result: the art reads as intended in a monospace context. If it looks skewed, the font is likely proportional rather than fixed-width.

Limitations to watch for

• Font and spacing differences are the main failure point. Proportional fonts collapse the alignment that ASCII art depends on.
• Platform wrapping can break multi-line pieces if the text box is too narrow.
• No color — ASCII art is monochrome by nature, unlike emoji.
• Emoji substitution — some apps auto-convert certain character sequences into emoji, which can corrupt the art.

If your art keeps breaking, switch to a monospace font, widen the container, or use emoji/kaomoji instead.

Text art is any image made from characters rather than pixels — letters, punctuation, block glyphs, and sometimes color codes. The two forms you'll meet most often are ASCII art (plain characters, no color) and ANSI art (characters plus color and cursor control, usually from the BBS era). If you just want to look at a file, open it in a viewer or terminal that supports its character set and font; if you want a shareable image, convert it to PNG with a tool like Ansilove.

The main forms of text art

The practical difference between ASCII and ANSI art is color and character set. ASCII art relies on the shape of standard characters alone, so it looks the same anywhere the font is monospaced. ANSI art adds escape sequences that set foreground and background colors and move the cursor, so it only looks right when the viewer interprets those codes. A .ans file opened in a plain text editor will show garbage characters mixed with the art.

Common file formats

• .ans — ANSI art with color codes. The core format for BBS-era art.
• .asc — plain ASCII art, no color codes.
• .nfo — scene release info files, often ASCII or ANSI with box-drawing characters.
• .xb, .adf, .idf — extended/other text-mode formats from non-PC platforms.
• Artpacks — archives (often .zip) bundling many art files from a group or period. You extract them and open individual files.

How to view text art correctly

1. Pick a viewer that understands the format. For .ans files, use an ANSI-aware viewer or terminal. A plain text editor will not render the colors.
2. Use a monospaced font. Text art is drawn on a character grid; a proportional font breaks the alignment.
3. Match the character set. ANSI art typically uses CP437 (the original IBM PC character set). If your viewer uses a different encoding, block characters and line-drawing glyphs will appear wrong.
4. Check the font for extended glyphs. Some art depends on specific fonts. Ansilove, for example, documents support for the Spleen 8x16 font, which has full CP437 coverage, and handles font selection from SAUCE metadata — the metadata block that records which font and mode an art file expects.

If the art looks like random symbols, the encoding is wrong. If it looks like the right shapes but no color, you're viewing it as plain text.

Converting ANSI or ASCII art to PNG

Ansilove is a set of tools that convert ANSI and artscene-related file formats into PNG images. The workflow is:

1. Get the tool. Download from the Ansilove site. Recent releases include ansilove 4.2.2 (June 10, 2026) and libansilove 1.4.2.
2. Run it against your file. Point it at the .ans, .asc, or other supported file.
3. Check the output PNG. The converter renders the characters with the correct font and applies the color codes, so the result matches how the art was meant to look.

Why convert at all? PNG output is portable — it displays identically everywhere, doesn't depend on the viewer's font or encoding, and can be posted or archived without the original toolchain.

Troubleshooting common display problems

• Wrong font or broken block characters — the viewer isn't using the font the art expects. Select the correct font (for example, an Amiga Topaz or Spleen variant) or let the converter read the SAUCE metadata. Note that font selection from SAUCE metadata has had fixes (ansilove 4.2.2 fixed "Amiga Topaz 1" font selection).
• Missing colors — you're viewing a .ans file as plain text. Use an ANSI-aware viewer or convert to PNG.
• Garbled characters — encoding mismatch. ANSI art is usually CP437; set your viewer or terminal to that encoding.
• Font table issues — some fonts weren't reachable due to entry-count bugs (fixed in 4.2.2 so topaz500+ is reachable). If a font seems missing, update the tool.

Choosing what to do

• Just want to see it? Use an ANSI-aware viewer with a monospaced font and CP437 encoding.
• Want to share or archive it? Convert to PNG with Ansilove so it renders the same for everyone.
• Working with artpacks? Extract the archive first, then open or convert individual files.
• Building something? libansilove is the library behind the converter, used by other projects including Durdraw, Abydos, and Textfiles.com.

ANSI art is text-mode artwork that uses ANSI escape sequences to add color, cursor positioning, and extended characters on top of the printable-character grid that ASCII art relies on. If you have a .ans, .adf, or .pcb file from a BBS or artscene artpack and want to see it as intended — or turn it into a PNG — you need a viewer or converter that understands those escape codes, not a plain text editor. Ansilove is one such converter: it turns ANSI and artscene-related formats into PNG images.

ANSI art vs. ASCII art

Both are built from a character grid, but they differ in what controls the grid.

The practical consequence: an ASCII art file usually renders the same everywhere, while an ANSI art file depends on the terminal or renderer interpreting its escape sequences and font correctly. Open an ANSI file in a plain text editor and you will often see raw escape codes mixed with the artwork.

Where ANSI art files come from

ANSI art is closely tied to the BBS (bulletin board system) era and the artscene. Files circulated in artpacks, and different BBS software produced or expected different formats. Common extensions include .ans, .adf, and .pcb (PCBoard). Because these formats encode color and cursor behavior differently, a converter needs explicit support for each one rather than treating them all as plain text.

How to view ANSI art

• In a terminal: If your terminal supports ANSI colors, cat-ing a .ans file can work for simple pieces, but cursor-positioning sequences and non-standard fonts may render incorrectly.
• With a dedicated viewer or converter: Tools like Ansilove render the file to an image, which fixes the appearance regardless of your terminal. This is the more reliable option for archival or sharing.
• Online tools: Web-based viewers exist, but check whether they support the specific format (.ans vs. .adf vs. .pcb) before relying on them.

How to convert ANSI art to PNG with Ansilove

Ansilove is described as "a set of tools to convert ANSi and artscene related file formats into PNG images." The general workflow:

1. Get the tool. Download it from the project's downloads page. The project publishes ansilove (the command-line tool) and libansilove (the underlying library) as separate releases.
2. Run it against your file. Point the tool at your ANSI/artscene file and specify a PNG output. The expected result is a PNG that reproduces the original colors, characters, and layout.
3. Check the output. Compare against the original in a terminal or a known-good reference. If colors or glyphs look wrong, the cause is usually font selection, format detection, or metadata (see below).

Version notes that affect rendering

The project's changelog shows that rendering correctness has been an ongoing concern:

• ansilove 4.2.2 (June 10, 2026): fixed "Amiga Topaz 1" font selection from SAUCE metadata, and fixed the font table entry count so topaz500+ is reachable.
• ansilove 4.2.1 (March 24, 2025): documented support for the Spleen 8x16 font.
• ansilove 4.2.0 (May 23, 2023): added support for the Spleen 8x16 font, requiring libansilove >= 1.4.0.
• libansilove 1.4.0 (May 23, 2023): added font data for Spleen 8x16 with full CP437 support.
• libansilove 1.4.1 (May 28, 2023): synced the embedded Spleen 8x16 to Spleen 2.0.0, which swapped arrows at positions 1A and 1B.
• libansilove 1.3.0 (April 14, 2022): properly handles 512-character XBin fonts.
• libansilove 1.3.1 (April 26, 2022): fixed XBin font memory leaks and adjusted PCBoard buffer handling.

If you are converting files that use Spleen 8x16, Amiga Topaz, or XBin fonts, using an older version can produce visibly wrong output.

Common problems and what causes them

• Colors look wrong or missing. The renderer may not be interpreting the escape sequences, or the file may use a palette your tool doesn't map correctly.
• Wrong glyphs or missing characters. This is usually a font issue — the selected font may not cover the character set the file uses (for example, CP437). The Spleen 8x16 and XBin-related fixes above are examples of this class of bug.
• SAUCE metadata causes unexpected font selection. SAUCE is metadata embedded in the file that can specify things like the font. A bug in reading it (as fixed in ansilove 4.2.2 for "Amiga Topaz 1") can make the converter pick the wrong font.
• File format not recognized. .ans, .adf, and .pcb are different formats. Confirm your tool supports the specific one you have.

Choosing between viewing and converting

If you just want to see the art, a terminal or viewer may be enough — but results vary by terminal. If you need a stable, shareable, or archival copy, converting to PNG with a tool like Ansilove is the more dependable route, especially for files that use non-default fonts or SAUCE metadata. When in doubt, convert with a current release and compare the PNG against the original before treating it as accurate.