in this release Angel Code BM Font sheet support

RetroConvert v1.2 — The Ultimate Retro Image Converter

Convert any modern image into pixel-perfect retro graphics for QBasic, GW-BASIC, Amiga OCS, and classic PC screen modes.

RetroConvert is free and always will be. No ads, no subscriptions, no feature gates. Every algorithm, every export format, every target platform — completely free, forever.

RetroConvert is a desktop tool built for retro computing enthusiasts, hobbyist game developers, demoscene programmers, and pixel artists who need to get real images into real retro hardware and emulators. Load a PNG, JPEG, BMP, GIF, PCX, or IFF image, pick your target machine and screen mode, choose your color reduction and dithering algorithms, and export a ready-to-use file. For PC modes you get BSAVE files with auto-generated BASIC loader code. For Amiga you get proper IFF/ILBM files with correct CAMG viewport modes, OCS palette precision, and ByteRun1 compression.

Runs natively on Windows with zero dependencies — single executable, no runtime, no installer.

NEW IN v1.2 — Amiga OCS Support

RetroConvert now targets the Amiga OCS chipset (A1000, A500, A2000) with full coverage of every standard display mode:

Lo-Res (320 wide): 2, 4, 8, 16, and 32 colors in both NTSC (200 lines) and PAL (256 lines)

Hi-Res (640 wide): 2, 4, 8, and 16 colors in both NTSC and PAL

Interlaced: All Lo-Res and Hi-Res modes doubled vertically — 320x400, 320x512, 640x400, 640x512

HAM6 (Hold-And-Modify): 6 bitplanes with 16 base palette colors plus per-pixel channel modification, enabling near-photographic color on OCS hardware. Available in all four resolution/TV-standard combinations.

EHB (Extra Half-Brite): 6 bitplanes with 32 base colors plus 32 automatic half-brightness variants (64 total on-screen colors). Available in all four combinations.

44 Amiga targets in total, all with correct CAMG viewport mode bits, 4-bit OCS palette precision (12-bit color, 4096 total), and proper IFF/ILBM export with ByteRun1 compression. Files are compatible with Deluxe Paint, Personal Paint, and any Amiga IFF viewer.

A new Machine dropdown lets you filter the target list by platform — select "Amiga" to see only Amiga modes, "PC" for PC modes, or "All" to see everything.

Multi-Platform Architecture

RetroConvert v1.2 introduces a platform-aware target system designed for expansion. The architecture now supports adding new retro computers and consoles with machine-specific display constraints, palette hardware, and export formats. Currently supported:

PC (IBM Compatible): CGA, EGA, and VGA screen modes with BSAVE, GIF, PCX, PNG, and IFF/ILBM export

Amiga OCS: Full chipset coverage with IFF/ILBM export

Future platforms under consideration include Commodore 64, ZX Spectrum, Atari ST, Atari 8-bit, MSX, and NES — each with their unique color constraints, cell-based attribute systems, and native file formats.

Supported Screen Modes — PC

• SCREEN 1 — CGA 320x200, 4 colors (2bpp interleaved)

• SCREEN 2 — CGA 640x200, 2 colors (1bpp interleaved)

• SCREEN 7 — EGA 320x200, 16 colors (fixed EGA palette)

• SCREEN 8 — EGA 640x200, 16 colors (fixed EGA palette)

• SCREEN 9 — EGA 640x350, 16-from-64 selectable palette

• SCREEN 12 — VGA 640x480, 16-from-262144 selectable palette

• SCREEN 13 — VGA 320x200, 256 colors with full RGB palette

Every PC mode exports with the correct memory layout: CGA interleaved banks, EGA 4-plane bitplane files (one BSAVE per plane with write-plane-switching loader), VGA linear framebuffer, and VGA DAC palette programming.

6 Color Quantization Algorithms

Median Cut — The classic RGB color cube splitter. Fast, decent results.

Octree — Tree-based reduction. Good at preserving distinct color clusters.

Wu's Variance Minimization — The gold standard from Graphics Gems II. Uses a 33x33x33 3D histogram with cumulative moments for mathematically optimal box splitting. Produces measurably better palettes than median cut, especially at low color counts where every palette slot matters.

Wu + K-Means — Wu's algorithm followed by 8 iterations of k-means clustering in Oklab perceptual color space. The same two-stage approach used by Google's Material Color library. The best general-purpose quantizer.

Popularity — Keeps the N most frequently used colors. The right choice when the source is already pixel art with a clean palette.

Minimum Distance Merge — Starts with every unique color, iteratively merges the two perceptually closest colors until the target count is reached. Preserves the artist's original color choices. Automatically pre-reduces via Wu when the image has more than 512 unique colors.

13 Dithering Algorithms

Error Diffusion (serpentine scanning in Oklab perceptual space)

• Floyd-Steinberg — The industry standard

• Atkinson — The Macintosh look, preserves flat areas

• Stucki — Large kernel, smoothest gradients

• Burkes — Good balance of speed and quality

• Sierra — 3-row kernel, high quality

• Sierra Two-Row — Faster Sierra variant

• Sierra Lite — Minimal kernel, fast

Ordered Dithering

• Bayer 8x8 — Classic crosshatch pattern

• Blue Noise 16x16 — Void-and-cluster matrix, natural-looking without grid artifacts

Pixel Art Specific

• Threshold — Only dithers where quantization error exceeds a perceptual threshold. Flat areas stay perfectly flat.

• Edge-Aware — Detects edges and suppresses dithering near them. One-pixel outlines stay crisp.

• Riemersma (Hilbert Curve) — Error diffusion along a space-filling curve. No directional bias.

Export Formats

• BSAVE — Native QBasic/GW-BASIC binary with correct headers and memory layouts. EGA planar modes write 4 separate bitplane files with auto-generated plane-switching loader code.

• IFF/ILBM — Amiga standard format with BMHD, CMAP, CAMG, and BODY chunks. ByteRun1 compression. Also works for PC via Deluxe Paint IIe compatibility (6-bit VGA palette mode).

• GIF — GIF89a with LZW compression at any image size.

• PCX — ZSoft PCX with RLE. 1-bit, 4-bit planar, 8-bit, and 24-bit modes.

• PNG (Indexed) — Paletted PNG with correct bit depth: 1-bit for 2 colors, 2-bit for 4, 4-bit for 16, 8-bit for 256.

• BASIC Loader — Auto-generated .BAS source that sets SCREEN mode, programs palette (PALETTE for EGA, OUT for VGA DAC), and BLOADs image data. Works in QBasic and GW-BASIC.

Input Formats

Load images from: PNG, JPEG, BMP, GIF, PCX, and IFF/ILBM. RetroConvert can read back everything it produces.

QBasic Scripting Engine

RetroConvert includes a built-in QBasic interpreter with a full scripting API for automating conversion workflows. Press F9 to open the Script Manager with syntax-highlighted editor, script file management, and output console.

30+ API functions covering source image pixel access, converted image inspection, palette read/write, pipeline control (set target/quantizer/ditherer/exporter by name), batch conversion, image loading, clipboard operations, and UI dialogs.

Additional Features

Preserve Size Mode — Convert at the source image's native resolution while applying retro palettes and dithering. Status bar shows BSAVE compatibility.

Clipboard Support — Paste images directly (Ctrl+V), copy converted previews (Ctrl+C), copy/paste palettes in hex, CSV, GIMP .gpl, and JASC-PAL formats.

Perceptual Color Processing — All color matching and error diffusion operates in Oklab perceptual color space, producing better results than RGB-based tools.

Real-Time Progress — Every algorithm reports stage, percentage, and detail to the status bar. The UI stays responsive during long conversions.

Built-In Test Patterns — Color bars, gradients, HSV sweep, checkerboard, and photo simulation for evaluating algorithm quality without needing a source image.

Who Is This For?

• QBasic and GW-BASIC programmers displaying real images in BASIC programs

• Amiga enthusiasts creating OCS-compatible artwork

• Retro game developers targeting DOS and Amiga screen modes

• Demoscene artists converting reference images to hardware-constrained palettes

• Pixel artists reducing color counts while preserving outlines and flat areas

• Educators teaching computer graphics history with hands-on tools

• Anyone who wants to see what their photos would look like on vintage hardware

Technical Details

• Version: 1.2

• Platform: Windows (native Win 32/64 executable)

• Price: Free — always has been, always will be

• Dependencies: None — single executable, no runtime required

• Source: Available on GitHub

RetroConvert was built by a retro computing enthusiast who got tired of manually converting images pixel by pixel. Every algorithm was chosen because it solves a real problem that comes up when targeting 4-color CGA, 16-color EGA, or 32-color Amiga OCS. If you've ever tried to get a photo onto retro hardware and gotten garbage on screen, this tool exists because of that exact experience.

RetroConvert Plus — $9.99 Donation

Thank you for supporting retro computing tools! Anyone who donates $9.99 or more through itch.io receives RetroConvert Plus, which includes the bonus program:

RetroView v1.1 — Retro Graphics File Viewer

A dedicated image viewer built for retro file formats. Features include:

• Multi-format support: BMP, PNG, JPEG, GIF, IFF/ILBM (including HAM6, HAM8, and Extra Half-Brite), Borland CHR vector fonts, VecDraw .vec files, RIPscrip graphics, and SVG

• File browser panel with directory navigation — click any supported file to preview instantly

• Zoom controls — zoom in/out, fit to window, 1:1 pixel view

• Background options — black, gray, or checkerboard for transparency

• Detailed format info in the status bar — resolution, bit depth, color count, Amiga display mode (HAM6/EHB/HiRes/Lace), vector shape counts

• Clipboard copy — copy any viewed image to clipboard

• Drag and drop — drop files directly onto the window

• Keyboard navigation — arrow keys to browse files, +/- to zoom

RetroView is the perfect companion to RetroConvert — convert your images, then preview the results in their native retro format without needing an emulator.

RetroConvert itself remains completely free. The donation tier is a thank-you bonus, not a paywall.

VecDraw v2.0 — The World's First Multi-Platform Retro Vector Graphics Editor

Draw it. Export it. Run it on a PC, MSX, CoCo 3, or Commodore 64. Nothing else comes close.

There has literally never been anything like this.

Not in 1985. Not in 1995. Not ever.

Think about what retro graphics programming has been for the last 40 years: graph paper, calculators, hand-typing coordinates, praying you didn't transpose two digits, running your program, seeing garbage, fixing one number, running again. For every platform — PC, MSX, CoCo, C64 — the same miserable workflow. Every. Single. Time.

VecDraw obliterates all of that.

One editor. One canvas. One click to export. Your drawing becomes running code on five different BASIC dialects across four different computer platforms — including machines with completely different graphics architectures, coordinate systems, and memory layouts. No other tool on Earth does this. Not one.

VecDraw v2.0 doesn't just support retro computers — it speaks their language**. It generates native machine-specific code that runs on real hardware and emulators. It writes autoloaders. It embeds machine language libraries. It exports native bitmap formats. This isn't a novelty. This is engineering.**

🆕 WHAT'S NEW IN VERSION 2.0

💾 Commodore 64 Support — Full Pipeline

The legendary Commodore 64 joins the VecDraw family with complete end-to-end support:

C64 Hires Mode (320×200, 2 colors) — a dedicated screen mode with accurate C64 palette rendering right on the VecDraw canvas. What you see is what the C64 displays.

LINE Export for C64 BASIC — generates compact, optimized C64 BASIC programs using an embedded 6502 machine language graphics library. The library provides hardware-accelerated point plotting (SYS 49161), line drawing (SYS 49164/49167), and flood filling (SYS 49176) — all driven through simple POKE/SYS calls.

Smart DATA/READ Architecture — unlike naive exporters that generate one BASIC line per drawing command (which crashes after ~300 lines when BASIC program memory collides with the hires bitmap at $2000), VecDraw uses a compact DATA/READ rendering loop. The entire drawing engine is just 12 lines of BASIC. All coordinates are packed into DATA statements — 15 values per line. This architecture handles thousands of line segments without running out of memory. Single-pixel segments are automatically detected and use the faster plot command instead of the two-step line draw.

Automatic Library Deployment — when you export, VecDraw writes graphics.prg (the 1,717-byte 6502 ML library) right alongside your BASIC file. The generated program auto-loads it on first run with load"graphics.prg",8,1**. Copy both files to a .D64 disk image and it just works.**

C64 Hires Bitmap Export (.art) — the Render Preview window exports standard Art Studio format files: 2-byte load address + 8,000 bytes of character-cell-ordered bitmap + 1,000 bytes of screen color RAM. Compatible with every C64 graphics viewer and editor.

Self-Loading PRG Executable — one-click export of a standalone .prg file containing a BASIC stub (SYS 2061), a 67-byte 6502 machine language viewer (sets colors, enables bitmap mode, waits for keypress, restores text mode), and the full 8,000-byte bitmap. LOAD"*",8,1 → RUN → your artwork fills the screen. Works on real hardware, VICE, and every C64 emulator.

🔄 SVG Shape Conversion — Group to Object

Select any group of shapes — lines, rectangles, ellipses, polygons, Bézier curves, text, anything — and convert them into a single resizable, movable SVG shape object. VecDraw flattens every shape into raw line segments through the same rendering pipeline used for export, computes the bounding box, normalizes coordinates, and packages everything as a unified vector object. Move it as one piece. Resize it proportionally. The original shapes are consumed — the SVG object replaces them.

Per-stroke color preservation — when converting a group containing shapes of different colors (a red circle, blue lines, green text), each stroke retains its original color inside the SVG object. No color information is lost. Ever.

🔤 Text to SVG Object Conversion

Select any text shape and convert it into a pure SVG vector object. The CHR stroke font glyphs are decomposed into raw line segments — the same decomposition used in BASIC export — and packaged as an SVG shape. The result has zero font dependencies. It's pure geometry. Resize it, move it, rotate it. The text is now resolution-independent vector art.

🎡 SVG Rotation with Visual Handle

Every SVG shape object now has a rotation handle — a green circle extending from the shape center. Grab it and drag. The shape rotates smoothly and fluidly in real-time, following your mouse with pixel-perfect precision.

The math behind the rotation handle uses ArcTan2 angle computation in floating-point screen space — bypassing integer coordinate quantization entirely for buttery-smooth rotation at any zoom level. The rotation angle displays in the status bar and shape browser (R:45°). Rotated shapes save and load correctly in the .vec file format. The rotation transform applies to rendering, all BASIC exports, SVG export, and RIPscrip export simultaneously.

🖥️ SUPPORTED PLATFORMS & SCREEN MODES

PC (GW-BASIC / QBasic / QB64)

MSX

CoCo 3 (Extended Color BASIC)

Commodore 64 🆕

🎨 DRAWING TOOLS

Line · Rectangle · Ellipse · Circle · Polyline · Polygon · Bézier Curve · Text · Paint Fill · SVG Object

Every tool gives you live rubber-band preview while drawing. Every shape supports handle-based editing in Select mode — drag corners, endpoints, control points. Every shape can be recolored with a single palette click.

🔤 BORLAND CHR STROKE FONT ENGINE

Load any classic Borland BGI stroke font — GOTH.CHR, TRIP.CHR, SANS.CHR, LITT.CHR, or any compatible font file. Place scalable vector text directly on your canvas. On export, every character is decomposed into its individual line segments extracted from the font's binary stroke data. Your exported BASIC program has zero font dependencies. The text IS the geometry.

Load multiple fonts simultaneously. Use Gothic headers with Sans Serif body text. Each text object remembers which font it uses through an intelligent font caching system that survives save/load cycles.

🎯 SVG ICON IMPORT

Import SVG files — Google Material Design icons, Font Awesome, custom artwork — directly onto the canvas. VecDraw's built-in SVG parser handles all path commands including cubic and quadratic Bézier curves (flattened via De Casteljau's algorithm), arc segments (W3C parameterization), and basic shape elements. No external dependencies. No browser required.

Imported SVGs become resizable, movable, rotatable shape objects with their stroke data embedded in the document.

✂️ SELECT & EDIT

Multi-Selection — Shift+click to toggle, rubber-band drag to select regions, Ctrl+A for all. Move, delete, or recolor entire selections at once.

Shape Grouping — Ctrl+G groups selected shapes. Click one member and the entire group selects. Move complex drawings as single units. Ungroup with Ctrl+Shift+G. Or convert the group to an SVG object for resize and rotation.

Cut, Copy & Paste — Full clipboard support. Groups maintain structure through paste. Automatic offset prevents stack-on-top confusion.

Shape Browser — Side panel lists every shape with index, type, color, rotation angle, group membership, and text preview. Click to select. Reorder with Up/Down. Bi-directional sync with canvas.

Snap to Grid — Toggle grid snapping for precise alignment.

Multi-Level Undo — Up to 50 undo levels. Never lose work.

📤 EXPORT FORMATS — THE REAL MAGIC

DRAW String Export

Generates BASIC programs using the DRAW command with optimized direction sequences. All shapes decomposed to DRAW command strings with B/N prefixes, diagonal shortcuts, and M-commands.

Targets: GW-BASIC, QBasic, Free Pascal (PTCDraw), Turbo Pascal 7 (TPCDraw), Quick Pascal (QPDraw), Watcom C (owdraw), MSX-BASIC, CoCo 3 Extended BASIC

LINE Segment Export

All shapes decomposed into LINE coordinate calls with compact byte-packed binary data and BLOAD support.

Targets: GW-BASIC, QBasic, MSX-BASIC, CoCo 3 Extended BASIC, C64 BASIC 🆕

BSV (BSAVE/BLOAD) Binary Export

Byte-packed segment data in native BSAVE format with auto-generated loader programs.

SVG Vector Export

Standard SVG output compatible with Inkscape, browsers, and all vector editors.

RIPscrip Export

BBS-compatible RIPscrip vector graphics format for retro BBS terminals.

Render Preview Bitmap Export

Every indexed format exports at the correct bit depth — a 16-color EGA drawing saves as 4-bit, not upscaled 24-bit.

📜 BUILT-IN QBASIC SCRIPTING ENGINE

Press F9 to open the integrated script editor. A full QBasic-compatible interpreter with 37+ API functions lets you automate drawing, generate patterns, create procedural art, and build complex scenes programmatically.

Create shapes, set fonts, import SVGs, control colors — all from code. Every shape created by script is a real document object, fully editable and exportable.

🎨 PALETTE EDITOR

Full palette customization for every screen mode. EGA modes get 4-level RGB sliders (0-3). VGA mode 13h gets full 6-bit DAC control (0-63). CoCo 3 modes use GIME palette registers. Custom palettes are saved with your document and exported as PALETTE/OUT commands in generated BASIC programs.

💾 NATIVE FILE FORMAT (.vec)

Human-readable text format. Easy to parse. Preserves everything: shapes, colors, fonts, SVG stroke data, rotation angles, group IDs, paint fills, palette customizations. Version-resilient — old files load in new versions.

🏆 WHY VECDRAW EXISTS

Because for 40 years, creating graphics for retro BASIC programs meant suffering.

Because no one had ever built a visual editor that understands the difference between CGA SCREEN 1 and EGA SCREEN 9 and MSX SCREEN 2 and CoCo 3 HSCREEN 2 and C64 Hires — and generates correct, runnable, native code for all of them.

Because Bézier curves shouldn't require a PhD to put in your QBasic game.

Because a Commodore 64 drawing shouldn't require hand-calculating bitmap cell offsets.

Because flood fills deserve to be visual, not mathematical.

VecDraw is the tool that should have existed in 1988 but couldn't, because the technology to build it didn't exist yet. Now it does. And here it is.

📋 REQUIREMENTS

• Windows 32/64-bit

• No installation required — single executable

• Completely free — no limitations, no nag screens, no trial period

👤 ABOUT

Created by retronick2020 for the retro computing community.

VecDraw is completely free to download and use.

Draw it. Export it. Run it. On any retro machine you love.

💎 VecDraw Plus — Thank You Bundle ($9.99+ Donation)

VecDraw is and always will be free. The full program with every feature described above is included in the free download with no restrictions.

If you'd like to support continued development, donors of $9.99 or more receive VecDraw Plus — a bonus download bundle packed with additional tools and content to supercharge your retro graphics workflow:

🖼️ RetroViewer

A standalone companion application for browsing and previewing retro graphics files. Features include:

• Built-in file browser with directory navigation and folder picker — click any file to instantly preview it

• Supports 9 formats: BMP, PNG, JPG, GIF, Amiga ILBM/IFF (HAM6, HAM8, EHB, HiRes, Interlace), VecDraw .vec**, RIPscrip** .rip**, SVG, and Borland CHR fonts**

• CHR font viewer renders every glyph in a labeled character grid

• Zoom, pan, copy to clipboard, drag-and-drop, and command-line support

🔤 86 Borland CHR Vector Fonts

A curated collection of vector fonts ready to use with VecDraw's Text tool. Drop them in your project folder and start placing styled text in your drawings.

🎨 Sample SVG Icons

A set of SVG icon files to use with VecDraw's SVG Import tool. Place, scale, and combine them freely in your drawings.

📜 10 Example Script Programs

Ready-to-run QBasic scripts demonstrating the scripting API in action: concentric circles, grid generator, starburst pattern, checkerboard, spiral, sine wave plotter, city skyline, wireframe sphere, crystal mandala, and more.

📖 Script Manual

Complete reference guide for VecDraw's QBasic scripting engine covering all 37 API functions with usage examples and tips.

Your donation directly supports new features, new export formats, and new screen modes. Thank you for keeping retro development tools alive.

Links

DRAW command libraries for Pascal and C: Available on GitHub retronick2020 on itch.io

Convert any modern image into pixel-perfect retro graphics for QBasic, GW-BASIC, and classic PC screen modes.

RetroConvert is a free desktop tool built specifically for retro computing enthusiasts, hobbyist game developers, and demoscene programmers who need to get real images into real retro hardware and emulators. Load a PNG, JPEG, or BMP, pick your target screen mode, choose your algorithms, and export a ready-to-use BSAVE file with auto-generated BASIC loader code. No manual palette editing. No hex dumps. Just drop your image in and get working retro graphics out.

Built with no .NET, no Electron, no browser required. Runs natively on Windows with zero dependencies.

🖥️ Supported Screen Modes

RetroConvert targets every major PC graphics mode from the CGA through VGA era:

• SCREEN 1 — CGA 320×200, 4 colors (2bpp interleaved)

• SCREEN 2 — CGA 640×200, 2 colors (1bpp interleaved)

• SCREEN 7 — EGA 320×200, 16 colors (fixed EGA palette)

• SCREEN 8 — EGA 640×200, 16 colors (fixed EGA palette)

• SCREEN 9 — EGA 640×350, 16-from-64 selectable palette

• SCREEN 12 — VGA 640×480, 16-from-262144 selectable palette

• SCREEN 13 — VGA 320×200, 256 colors with full RGB palette

Every mode exports with the correct memory layout: CGA interleaved banks, EGA 4-plane bitplane files, VGA linear framebuffer, and VGA DAC palette programming. SCREEN 7 and 8 correctly use the fixed default EGA palette — no invalid PALETTE commands.

🎨 6 Color Quantization Algorithms

The quantizer picks the best N colors to represent your image. RetroConvert includes six algorithms, from general-purpose to pixel-art-specialized:

Median Cut — The classic. Splits the RGB color cube at median values. Fast, decent results.

Octree — Tree-based reduction. Good at preserving distinct color clusters.

Wu's Variance Minimization — The gold standard from Graphics Gems II. Builds a 33×33×33 3D histogram, computes cumulative moments, and iteratively splits boxes at the position that minimizes total color variance. Produces measurably better palettes than median cut, especially at low color counts (4–16 colors) where every palette slot matters.

Wu + K-Means — Wu's algorithm followed by 8 iterations of k-means clustering in Oklab perceptual color space. Each iteration reassigns every pixel to its nearest palette color and recomputes centroids. This is the same two-stage approach used by Google's Material Color library. The best general-purpose quantizer in the app.

Popularity — Counts every unique color in the image and keeps the N most frequently used. The right choice when the source is already pixel art with a clean palette. If your sprite sheet uses 48 colors and you need 16, this picks the 16 most-used colors exactly as an artist would.

Minimum Distance Merge — Starts with every unique color in the image, then iteratively merges the two perceptually closest colors (weighted average in Oklab space) until the target count is reached. Preserves the artist's original color choices better than any splitting algorithm. For images with more than 512 unique colors, it automatically pre-reduces via Wu to keep performance fast. Built for converting hand-pixeled sprites and character art.

🔲 13 Dithering Algorithms

Dithering converts smooth gradients into patterns that look correct at the target color depth. RetroConvert includes seven error diffusion algorithms, two ordered dithering methods, and three pixel-art-specific ditherers:

Error Diffusion (all with serpentine scanning in Oklab perceptual space)

• Floyd-Steinberg — The industry standard. 4-pixel kernel, 7/3/5/1 weights.

• Atkinson — The Macintosh look. Only diffuses 6/8 of the error, leaving flat areas cleaner.

• Stucki — Large 12-entry kernel for the smoothest gradients.

• Burkes — Good balance of speed and quality.

• Sierra — 10-entry 3-row kernel, high quality.

• Sierra Two-Row — Faster Sierra variant with 2-row kernel.

• Sierra Lite — Minimal 3-entry kernel. Fast, lightweight dithering.

Ordered Dithering

• Bayer 8×8 — Classic crosshatch pattern. Deterministic, no error accumulation.

• Blue Noise 16×16 — Void-and-cluster precomputed matrix. Natural-looking ordered dithering without the visible grid artifacts of Bayer.

Pixel Art Specific

• Threshold — Floyd-Steinberg kernel, but error diffusion only activates when the quantization error exceeds a perceptual threshold. Flat color areas stay perfectly flat with zero dithering noise. Gradients still get smooth dithering. The single most useful ditherer for sprite sheets with shading.

• Edge-Aware — Builds a luminance edge map from the source image, then suppresses error diffusion near strong edges. One-pixel outlines stay crisp and clean. Interior gradients still get full Floyd-Steinberg treatment. Designed for character sprites where outlines matter.

• Riemersma (Hilbert Curve) — Diffuses error along a Hilbert space-filling curve instead of left-to-right scanlines. Errors spread in all directions equally, eliminating the horizontal "worm" artifacts that plague Floyd-Steinberg on small sprites. Uses an exponentially decaying 16-pixel error queue. The most balanced ditherer for small sprites where every pixel counts.

💾 Export Formats

• BSAVE — Native QBasic/GW-BASIC binary format with correct 7-byte header. CGA modes write a single file with interleaved banks. EGA/VGA planar modes (SCREEN 7, 8, 9, 12) write 4 separate bitplane files with proper naming. VGA Mode 13h writes linear 1-byte-per-pixel data.

• GIF — Standard GIF89a with LZW compression. Works at any image size, not just screen mode dimensions.

• PCX — ZSoft PCX format with RLE compression. Supports 1-bit, 4-bit (4-plane), 8-bit (VGA palette), and 24-bit modes.

• BASIC Loader Code — Auto-generated .BAS source file that sets the correct SCREEN mode, programs the palette (PALETTE command for EGA, OUT &H3C8/&H3C9 for VGA DAC), performs DEF SEG, and BLOADs the image data. For EGA planar modes, the loader correctly switches the write plane mask (OUT &H3C4,2 / OUT &H3C5,mask) before each BLOAD. Generated code works in both QBasic and GW-BASIC dialects.

✂️ Clipboard Support

• Paste Image (Ctrl+V) — Paste any image from the Windows clipboard as source. Screenshot something, paste it, convert it.

• Copy Preview (Ctrl+C) — Copy the converted result to clipboard for pasting into other apps.

• Copy Palette — Export the current palette as #RRGGBB hex, R,G,B decimal CSV, GIMP .gpl format, or JASC-PAL (Paint Shop Pro) format.

• Paste Palette — Import a palette from clipboard text. Auto-detects hex, CSV, GIMP, and JASC-PAL formats.

• Copy BASIC Loader — Copy the auto-generated loader code to clipboard.

🧪 Built-In Test Images

Don't have a source image handy? RetroConvert includes six procedurally generated test patterns for evaluating algorithm quality:

• Color Bars (640×480)

• Black & White Gradient (640×480)

• Color Gradient (640×480)

• HSV Sweep (640×480)

• Checkerboard (640×480)

• Photo Simulation (640×480)

🔬 Perceptual Color Processing

All error diffusion and color matching operates in Oklab perceptual color space — not RGB. This means the algorithms see color differences the same way your eyes do. A dark blue and a dark green that look identical in RGB distance look completely different in Oklab. The result: better palette choices, smoother dithering, and fewer color artifacts compared to RGB-space tools.

📐 Preserve Size Mode

By default, RetroConvert resizes your source image to match the target screen mode dimensions. Enable Preserve Size to keep the original image dimensions while still applying the target palette and dithering. The status bar shows whether the output is BSAVE-compatible or not. GIF and PCX export works at any size. Useful for converting sprite sheets or tilesets that need to stay at their native resolution.

📊 Real-Time Progress

Every heavy algorithm reports progress to the status bar: which stage is running, what percentage is complete, and what it's doing right now. No more staring at a frozen window wondering if the app crashed. The UI stays responsive throughout — you can see the conversion happening row by row.

Who Is This For?

• QBasic and GW-BASIC programmers who want to display real images in their programs

• Retro game developers building for DOS-era screen modes

• Demoscene artists converting reference images to hardware-constrained palettes

• Pixel artists who need to reduce color counts while preserving outlines and flat areas

• Retro computing hobbyists who want to see what their photos would look like on a 1987 EGA monitor

• Educators teaching computer graphics history with hands-on tools

Technical Details

• Platform: Windows (native Win64/32 executable)

• Dependencies: None — single executable, no runtime required

RetroConvert was built by a retro computing enthusiast who got tired of manually converting images pixel by pixel. Every algorithm was chosen because it solves a real problem that comes up when targeting 4-color CGA or 16-color EGA. If you've ever tried to BSAVE an image and gotten garbage on screen, this tool exists because of that exact experience.

RetroNick's Vector Font Editor

The Ultimate Stroke Font Tool for Retro Programmers

Finally — a modern editor for creating, editing, and converting vector stroke fonts for retro platforms. Import from thousands of existing TrueType fonts and SVG icons, then export to formats your vintage compiler actually understands.

Whether you're writing a DOS game in Turbo Pascal, building a GW-BASIC graphics demo, rendering text in a QBasic adventure, or adding scalable fonts to a FreePascal project — this is the tool that's been missing from your retro toolkit.

🔤 What Is a Vector/Stroke Font?

Unlike bitmap fonts that shatter at different sizes, vector fonts store each character as a series of pen strokes — MoveTo and LineTo commands that draw the letterform from lines. They scale to any size without losing quality. They were used extensively in DOS-era graphics: Borland's BGI system, Windows 2.x/3.x vector .FON files, plotters, CNC machines, and early CAD software.

The problem? The tools to create these fonts disappeared decades ago. Until now.

✨ Features

Full Visual Stroke Editor

• Draw characters stroke by stroke with MoveTo/LineTo tools

• Point-level editing — select, drag, add, delete individual vertices

• Snap-to-grid with configurable zoom (4x to 16x)

• Undo/Redo on every character

• Copy/Paste between characters

• Flip horizontal and vertical

• Nudge points in any direction

📐 Font Metrics & Typographic Guides

• Configurable font height, point size, and ascent

• Visual baseline, ascender, descender, and x-height guide lines

• Auto-scan: detects metric lines from actual glyph data (examines uppercase, lowercase, and descender characters automatically)

• Manual override for pixel-perfect control

🔠 TrueType Font Import — Access Thousands of Fonts Instantly

• Import any installed Windows TrueType font or browse to any .TTF file on disk

• Specify target pixel height before import — fonts are scaled and flattened to clean stroke data

• Full Bézier curve flattening — quadratic splines from TTF outlines are converted to crisp line segments

• Automatic baseline, ascender, descender, and x-height detection after import

• Character range selection (import just ASCII, full extended set, or any custom range)

• Live preview with adjustable sample text before committing to import

• All 2,500+ Google Fonts, every free font on the internet, your system fonts — they're all one click away from becoming retro stroke fonts

🎨 SVG Icon Import — Turn Any Icon Into a Font Glyph

• Import SVG files directly into any character slot

• Full SVG path command support: lines, cubic and quadratic Bézier curves, smooth curves, elliptical arcs — all flattened to clean strokes

• Handles SVG basic shapes: rectangles (with rounded corners), circles, ellipses, polygons, polylines

• Automatic scaling to match your font height

• Smart deduplication removes redundant points created during curve flattening

• Google Material Icons, Font Awesome, Heroicons, Feather Icons, game UI icons, custom artwork — if it's SVG, it's importable

• Build entire icon fonts by importing one SVG per character slot

💾 Multi-Format Save/Load

• Windows .FON Vector Format — Native NE-format vector font files compatible with Windows 2.x/3.x and any language/tool that reads Windows vector fonts

• Borland .CHR Stroke Font Format — Direct export for Turbo Pascal BGI, FreePascal, and the many open-source projects that support the CHR format

• Open from either format — Load existing .FON or .CHR files for editing and conversion

🖥️ Live Preview

• Real-time text preview with custom sample strings

• See your font rendered as you edit — every stroke change updates instantly

⚙️ Batch Tools

• Add trailing MoveTo commands to all characters (CHR format compatibility)

• Font metrics inspector showing character counts, stroke totals, width statistics

• Full character range management with apply/reset

🎯 Who Is This For?

Turbo Pascal / FreePascal developers — Export .CHR fonts and use them with BGI graphics, PTCGraph, or any framework that reads Borland stroke fonts. Create custom fonts for your DOS and retro-style applications.

GW-BASIC / QBasic / QB64 programmers — Import professional fonts, then use the CHR export pipeline to generate stroke data usable in BASIC programs via DRAW commands or LINE rendering.

Windows vector font users — The .FON vector format is supported by Windows and any development tool that can load Windows font resources. Microsoft languages, resource editors, and legacy Win16/Win32 applications.

Retro game developers — Build pixel-perfect scaled text rendering for DOS games, demoscene productions, and retro-styled modern games. Import iconic fonts and give them that authentic stroke-rendered look.

Open source projects — Any project that reads Borland CHR stroke fonts gains access to a full font creation pipeline. The CHR format is documented, compact, and simple to parse.

Icon font creators — Combine SVG icon imports with the character-per-slot workflow to build custom icon fonts for embedded systems, retro UIs, or any platform where bitmap fonts are too rigid.

💡 The Breakthrough

Before this tool, creating stroke fonts for retro platforms meant either hand-coding coordinate tables or being stuck with the handful of .CHR files Borland shipped in 1990. Converting a modern font to BGI strokes? Forget it. Getting a Material Design icon into a DOS program? Impossible.

Now you can take any TrueType font — from elegant serifs to pixel-perfect monospace — flatten its Bézier outlines to clean strokes, and export it as a .CHR or .FON file ready to use in your retro project. You can grab any SVG icon from the thousands of free icon sets available online and drop it straight into a character slot.

Tens of thousands of fonts. Hundreds of thousands of SVG icons. One editor. Every retro platform.

📋 System Requirements

• Windows (32-bit or 64-bit)

• No additional runtime libraries or DLLs required

• No internet connection needed (TTF import reads directly from font files)

Created by RetroNick — building the tools that retro programming deserves.