Guide

PNM/PBM/PGM/PPM Files: The Portable Bitmap Format Family Explained

PC By Pablo Cirre • Updated May 7, 2026

PNM Files: The Portable Bitmap Family (PBM, PGM, PPM, PNM)

The Netpbm family of formats — PBM (Portable BitMap), PGM (Portable GrayMap), PPM (Portable PixMap), and the collective umbrella PNM (Portable aNyMap) — are among the simplest image formats ever designed. Created by Jef Poskanzer in 1988 and developed through the Netpbm toolkit, these formats prioritize simplicity and portability over efficiency. Each format is either plain ASCII text or binary data with a minimal ASCII header, making them trivially parseable in any programming language without libraries. Despite their age and naivety, they remain in active use in scientific computing, image processing research, and Unix tool pipelines.

The Four Formats

PBM — Portable BitMap (1-bit black and white)

PBM stores bilevel (binary) images — every pixel is either black (1) or white (0). Used for scanned text, QR codes, barcodes, and any image that is purely binary.

ASCII format (P1):

P1
# Created by GIMP
4 4
0 0 0 0
0 1 1 0
0 1 1 0
0 0 0 0

Binary format (P4): Same header, pixel data packed 8 pixels per byte.

PGM — Portable GrayMap (8-bit or 16-bit grayscale)

PGM stores grayscale images where each pixel is a value from 0 (black) to MAXVAL (white). MAXVAL is specified in the header and can be up to 65,535 (for 16-bit grayscale).

ASCII format (P2):

P2
# Gradient
5 3
255
  0  63 127 191 255
  0  63 127 191 255
  0  63 127 191 255

Binary format (P5): Same header, raw binary pixel data (1 byte per pixel for MAXVAL ≤ 255, 2 bytes big-endian for MAXVAL > 255).

PPM — Portable PixMap (24-bit RGB)

PPM stores full-color images with three color channels (R, G, B), each from 0 to MAXVAL (typically 255).

ASCII format (P3):

P3
# 2x2 red and blue pixels
2 2
255
255   0   0    0   0 255
255   0   0    0   0 255

Binary format (P6): Same header, raw binary pixel data (3 bytes per pixel for 8-bit color).

PNM — Collective Name

PNM is not a separate format — it is the collective term for the family. A .pnm file can contain PBM, PGM, or PPM data. Most tools that accept .pnm automatically detect which subformat the file contains based on the magic number in the header.

PAM — Portable Arbitrary Map (extension)

PBM/PGM/PPM were extended by PAM (Portable Arbitrary Map, magic number P7) which supports arbitrary numbers of channels, enabling RGBA (4 channels) and other multi-channel images within the same framework.

Magic Numbers

Each format uses a two-character magic number in the header to identify the variant:

Magic	Format	Variant
P1	PBM	ASCII
P2	PGM	ASCII
P3	PPM	ASCII
P4	PBM	Binary
P5	PGM	Binary
P6	PPM	Binary
P7	PAM	Binary

Why These Formats Still Matter

Zero parser complexity: Reading a binary PPM file requires only:

Read lines until you find width, height, maxval in the header
Read width × height × 3 raw bytes for the pixel data

This makes PNM formats perfect for educational use, quick scripts, and systems where adding a library dependency is undesirable.

Pipeline-friendly: Unix pipe workflows can chain tools that output and input PNM:

# Capture screen → convert to grayscale → threshold → count black pixels
scrot - | pngtopnm | ppmtopgm | pgmthresh 128 | pbmminkowski -...

Netpbm toolkit: The Netpbm package includes over 300 programs for converting between image formats and performing basic image operations. On Linux: sudo apt install netpbm.

Reference format in research: Scientific image processing papers often use PNM as a reference format because readers can verify the exact pixel values by reading the ASCII text directly.

No patent encumbrance: PNM is completely free from patents or licensing restrictions. It can be implemented in any language, in any context, without legal concerns.

Converting To and From PNM

PNG to PPM (to get raw pixels for processing):

# Using ImageMagick
convert input.png output.ppm

# Using pngtopnm (Netpbm)
pngtopnm input.png > output.pnm

PPM to PNG (after processing, back to a useful format):

convert output.ppm result.png
# Or:
pnmtopng output.ppm > result.png

JPEG to PGM (grayscale for machine vision):

convert input.jpg -colorspace Gray output.pgm

PPM to JPEG:

convert input.ppm -quality 90 output.jpg
# Or:
ppmtojpeg input.ppm > output.jpg

Any format to PBM (bilevel thresholding):

convert input.png -threshold 50% output.pbm

PNM in Programming

Python (without PIL/Pillow)

Reading a binary PPM file from scratch:

def read_ppm(filename):
    with open(filename, 'rb') as f:
        assert f.readline().strip() == b'P6'
        # Skip comments
        line = f.readline()
        while line.startswith(b'#'):
            line = f.readline()
        width, height = map(int, line.split())
        maxval = int(f.readline().strip())
        data = f.read()
    pixels = []
    bpp = 1 if maxval <= 255 else 2
    for i in range(0, width * height * 3 * bpp, 3 * bpp):
        r = int.from_bytes(data[i:i+bpp], 'big')
        g = int.from_bytes(data[i+bpp:i+2*bpp], 'big')
        b = int.from_bytes(data[i+2*bpp:i+3*bpp], 'big')
        pixels.append((r, g, b))
    return width, height, maxval, pixels

C (minimal PPM reader)

#include <stdio.h>
#include <stdlib.h>

typedef struct { unsigned char r, g, b; } Pixel;

Pixel* read_ppm(const char *path, int *w, int *h) {
    FILE *f = fopen(path, "rb");
    int maxval;
    fscanf(f, "P6 %d %d %d ", w, h, &maxval);
    Pixel *img = malloc(*w * *h * sizeof(Pixel));
    fread(img, sizeof(Pixel), *w * *h, f);
    fclose(f);
    return img;
}

Performance Considerations

PNM binary formats are uncompressed — a 1920×1080 PPM file is exactly 1920 × 1080 × 3 = 6,220,800 bytes (~6 MB). For color images, this is larger than PNG by 2–10×. For workflows where disk space matters, PNG or TIFF are better choices.

The ASCII variants (P1, P2, P3) are even larger and slower to parse. Use binary variants (P4, P5, P6) for any performance-sensitive work.

Tools That Output or Accept PNM

SANE (Scanner Access Now Easy) — Linux scanner driver, outputs PNM
dcraw — RAW camera converter, can output PPM
GraphicsMagick / ImageMagick — full PNM support
GIMP — reads and writes PNM natively
OpenCV — reads PNM via cv2.imread()
Netpbm toolkit — 300+ specialized tools
ImageJ / Fiji — bioimage analysis tool, reads PNM

Related conversions

Frequent conversions across the catalogue:

Frequently Asked Questions

PBM (Portable BitMap) stores 1-bit black-and-white images. PGM (Portable GrayMap) stores grayscale images at 8 or 16 bits. PPM (Portable PixMap) stores full-color 24-bit or 48-bit RGB images. PNM (Portable aNyMap) is not a separate format — it is the collective name for the whole family. A .pnm file can contain PBM, PGM, or PPM data, and tools identify which subformat is present by the magic number (P1-P6) in the header.

PBM (Portable BitMap) stores 1-bit black-and-white images. PGM (Portable GrayMap) stores grayscale images at 8 ou 16 bits. PPM (Portable PixMap) stores full-color 24-bit ou 48-bit RGB images. PNM (Portable aNyMap) is not a separate formato — it is the collective name para the whole family. A .pnm arquivo can contain PBM, PGM, ou PPM data, e ferramentas identify which subformat is present pelo magic number (P1-P6) no header.

PBM (Portable BitMap) stores 1-bit black-and-white images. PGM (Portable GrayMap) stores grayscale images at 8 oder 16 bits. PPM (Portable PixMap) stores full-color 24-bit oder 48-bit RGB images. PNM (Portable aNyMap) is not a separate Format — it is the collective name für the whole family. A .pnm Datei can contain PBM, PGM, oder PPM data, und Werkzeuge identify which subformat is present by the magic number (P1-P6) im header.

PBM (Portable BitMap) stores 1-bit black-and-white images. PGM (Portable GrayMap) stores grayscale images at 8 o 16 bits. PPM (Portable PixMap) stores full-color 24-bit o 48-bit RGB images. PNM (Portable aNyMap) is not a separate formato — it is the collective name para the whole family. A .pnm archivo can contain PBM, PGM, o PPM data, y herramientas identify which subformat is present by the magic number (P1-P6) en el header.

On KaijuConverter every file is processed inside an isolated container, encrypted in transit (TLS 1.3) and at rest, and automatically deleted after 60 minutes with multi-pass overwrite. We never train on, share, or analyze user content. For maximum privacy on extremely sensitive material, prefer offline tools (ImageMagick, FFmpeg, LibreOffice) that you control end-to-end.

PNM is useful when you need the simplest possible format to parse or generate without any library dependencies. A binary PPM file can be read in about 10 lines of C code with no external libraries. PNM is also useful in Unix pipe workflows with the Netpbm toolkit, in scientific image processing where exact pixel values need to be inspected directly, and in educational contexts to teach image format concepts. PNG is better for everything else: it is compressed, widely supported, and nearly as simple to parse with a library.

PNM is useful when you need the simplesst possible formato to parse ou generate sem any library dependencies. A binary PPM arquivo can be read in about 10 lines of C code com no external libraries. PNM is also useful in Unix pipe workflows com the Netpbm toolkit, in scientific image processing where exact pixel values precisar be inspected directly, e in educational contexts to teach image formato concepts. PNG is better para everything else: it is comprimido, widely suportado, e nearly as simples to parse com a library.

PNM is useful when you need the einfachst possible Format to parse oder generate ohne any library dependencies. A binary PPM Datei can be read in about 10 lines von C code mit no external libraries. PNM is also useful in Unix pipe workflows mit the Netpbm toolkit, in scientific image processing where exact pixel values need to be inspected directly, und in educational contexts to teach image Format concepts. PNG is better für everything else: it is komprimiert, widely unterstützt, und nearly as einfach to parse mit a library.

PNM is useful when you need the simplest possible formato to parse o generate sin any library dependencies. A binary PPM archivo can be read in about 10 lines de C code con no external libraries. PNM is also useful in Unix pipe workflows con the Netpbm toolkit, in scientific image processing where exact pixel values need to be inspected directly, y in educational contexts to teach image formato concepts. PNG is better para everything else: it is comprimido, widely soportado, y nearly as simple to parse con a library.

For 95% of use cases, yes — server-side ImageMagick, FFmpeg and LibreOffice produce identical output to the same tools on your laptop. Desktop software wins for: extremely large files (multi-GB), batch jobs of thousands of files, scripted pipelines, or content too sensitive to upload. KaijuConverter caps at 25 MB per file on the free tier (up to 2 GB on paid plans).

ASCII variants (P1 for PBM, P2 for PGM, P3 for PPM) store pixel values as space-separated decimal numbers in plain text. They are human-readable and trivial to debug but produce very large files and are slow to parse. Binary variants (P4 for PBM, P5 for PGM, P6 for PPM) use the same ASCII header but store pixel data as raw bytes — much faster to read and write, and files are exactly width × height × bytes_per_pixel in size. Always use binary variants for performance-sensitive work.

ASCII variants (P1 para PBM, P2 para PGM, P3 para PPM) store pixel values as space-separated decimal numbers in plain text. They are human-readable e trivial to debug mas produce very large arquivos e are slow to parse. Binary variants (P4 para PBM, P5 para PGM, P6 para PPM) usar o mesmo queCII header mas store pixel data as raw bytes — much faster to read e write, e arquivos são exactly width × height × bytes_per_pixel in size. Always usar binary variants para performance-sensitive work.

ASCII variants (P1 für PBM, P2 für PGM, P3 für PPM) store pixel values as space-separated decimal numbers in plain text. They are human-readable und trivial to debug aber produce very large Dateien und are slow to parse. Binary variants (P4 für PBM, P5 für PGM, P6 für PPM) verwenden gleich wieCII header aber store pixel data as raw bytes — much faster to read und write, und Dateien are exactly width × height × bytes_per_pixel in size. Always verwenden binary variants für performance-sensitive work.

ASCII variants (P1 para PBM, P2 para PGM, P3 para PPM) store pixel values as space-separated decimal numbers in plain text. They are human-readable y trivial to debug pero produce very large archivos y are slow to parse. Binary variants (P4 para PBM, P5 para PGM, P6 para PPM) usar igual queCII header pero store pixel data as raw bytes — much faster to read y write, y archivos are exactly width × height × bytes_per_pixel in size. Always usar binary variants para performance-sensitive work.

Most format conversions are lossy by design — JPG, MP3, MP4, WebP all discard perceptual data to save bytes. Going through a lossy intermediate compounds the loss. To minimize visible/audible drift: convert from the original master, choose a higher quality setting, and avoid converting back and forth between lossy formats.

Use ImageMagick: `convert input.ppm output.png`. Or the Netpbm tool: `pnmtopng input.ppm > output.png`. In Python with Pillow: `from PIL import Image; Image.open("input.ppm").save("output.png")`. FFmpeg also handles PPM: `ffmpeg -i input.ppm output.png`. All these methods produce a lossless PNG from the uncompressed PPM pixel data.

Use ImageMagick: `convert input.ppm output.png`. ou the Netpbm tool: `pnmtopng input.ppm > output.png`. In Python com Pillow: `from PIL import Image; Image.open("input.ppm").save("output.png")`. FFmpeg also handles PPM: `ffmpeg -i input.ppm output.png`. All these methods produce a sem perdas PNG de the não comprimido PPM pixel data.

Use ImageMagick: `convert input.ppm output.png`. oder the Netpbm tool: `pnmtopng input.ppm > output.png`. In Python mit Pillow: `from PIL import Image; Image.open("input.ppm").save("output.png")`. FFmpeg also handles PPM: `ffmpeg -i input.ppm output.png`. All these methods produce a verlustfrei PNG von the uncompressed PPM pixel data.

Use ImageMagick: `convert input.ppm output.png`. o the Netpbm tool: `pnmtopng input.ppm > output.png`. In Python con Pillow: `from PIL import Image; Image.open("input.ppm").save("output.png")`. FFmpeg also handles PPM: `ffmpeg -i input.ppm output.png`. All these methods produce a sin pérdidas PNG de the uncompressed PPM pixel data.

Yes — KaijuConverter accepts multiple files in a single drop and returns a ZIP. For very large batches (thousands of files) consider command-line tools or our API: <code>find . -name "*.heic" -exec magick {} {.}.jpg \;</code> or similar one-liners scale to millions of files when run locally.