LazPaint: a layered image editor written in Free Pascal

A demo of a graphics library that became an editor

LazPaint is a free cross-platform image editor, like PaintBrush or Paint.Net, written in Lazarus using Free Pascal, and it uses the BGRABitmap library for its drawing operations.

The history in the README is the part that explains the project. LazPaint was started to demonstrate the capabilities of the graphic library BGRABitmap, and it provides advanced drawing functions in the Lazarus development environment. Both provided a source of inspiration for the other and finally LazPaint became real image editor. Thanks to the help of the Lazarus community, the program has been compiled on Windows, Linux, MacOS X, FreeBSD and Raspberry Pi.

That origin still shapes the project. It is a demonstration of a graphics library that happens to be a usable editor, rather than an editor that happens to use a library. The consequence is that the feature set follows what BGRABitmap can draw, which is why the filter and render lists below are long and specific, and why the layer effects are done with scripts rather than with a plug-in interface.

The reach across platforms is a direct result of Lazarus being a cross-platform toolkit for Free Pascal, and the set of platforms includes some that a commercial editor does not usually target, notably FreeBSD and Raspberry Pi. The screenshots in the README show a Linux build with a dark theme, a Windows build and a build on Puppy Linux, which is a reasonable sample of the range.

Downloads are offered for Windows, Mac and Linux from the project site, the application is also available in some Linux repositories through the Repology listings, and the wiki has a page on making the application portable. There is a donation link, with the note that it would allow the developer to buy carrots and beans for sustenance, which tells you what kind of project this is.

The widget toolkit switches with the platform, and the Makefile shows it

The build system is a Makefile rather than a project file, and its first job is to pick the right widget toolkit for the operating system.

The comment at the top of the file is the whole story. On Linux, TARGET can be Gtk2, which is the default, or Qt5. On FreeBSD, TARGET can be Gtk2, the default, or Qt5. On Windows, TARGET can be Win32, the default, or Qt5.

So there are three default toolkits, one per platform, and the choice of a different one is a single variable on the make command line. That is a different model from most applications, which pick a toolkit and then have separate branches for each platform, and it means the same source builds against three different widget sets.

The rest of the Makefile is a hand-rolled portability layer. The Windows branch sets the shell to cmd.exe, defines UNAME as Windows, and replaces the Unix tools with their winmake/ equivalents, so COPY becomes winmake/copyfile, REMOVE becomes winmake/remove, REMOVEDIR becomes winmake/removedir, CREATEDIR becomes winmake/createdir, and ECHOFILE becomes type. The non-Windows branch does the opposite and, on FreeBSD specifically, switches the shell to /usr/local/bin/bash rather than /bin/bash. The THEN variable is the command separator, which is an ampersand on Windows and a semicolon elsewhere.

The Linux section then handles packaging, with the target defaulting to Gtk2, a prefix discovered by asking the system, and a MULTIBIN flag that produces a per-toolkit package name such as lazpaint-qt5 with a separate prefix, which is how several toolkit builds coexist on one machine.

The icon handling is the other visible part of the Makefile. It identifies the icon file with the ImageMagick identify tool, extracts the embedded sizes into a list, and then declares the sizes it wants: 16x16, 24x24, 32x32, 48x48, 96x96, 128x128 and 256x256. The translation files are collected with a find over the i18n directory, and there are variables for the binary, script, icon and Debian upstream directories. The Free Pascal compiler binary and the project directory are discovered by asking small helper programs on the path, which is the older Free Pascal convention and worth knowing if you are trying to build it from a distribution package.

The repository top level reflects the same split, with lazpaint/ for the application, lazpaintcontrols/ for the UI controls, vectoredit/ for the vector editing side, resources/, web/ and use/ directories, winmake/ for the Windows make helpers, and a.gitmodules file for the BGRABitmap dependency.

The tools are the feature list, and they are broader than the name suggests

The features are grouped by what they do to an image, and reading them is the fastest way to understand what the application can do.

For files, it reads and writes a variety of file formats, including layered bitmaps and 3D files. For tools, many tools are available to draw on the layers. For editing and selection, it selects parts of an image with antialiasing and modifies the selection as a mask. The view side gives a colour window, a layer stack window and a toolbox window, and the command line mode lets you call LazPaint from a console.

The keyboard shortcuts are documented in a way that is genuinely useful, because they are the ones you cannot guess. Holding the Space key down switches temporarily into move mode, F6 hides or shows all the tool windows, the Ctrl key aligns to image pixels and limits possible angles with the rotation tool, the Backspace key erases the last point in a polygon or the last letter in a text, and the Enter key releases the selection. The right mouse button is overloaded with four meanings depending on context: swapping drawing colours temporarily, subtracting from the selection, defining the light position for shaded text and shaded shapes, and finishing a shape such as a polygon or a curve.

The undo history is 200 operations deep, and the README's advice about using it is practical: if you have a doubt on what you are drawing, undo back to the beginning, save a copy, and redo the modifications before going further. That is a workflow suggestion from someone who has watched people lose work.

On the interface, most common actions can be done with the toolbar, and zoom can be changed with the magnifying glass, by clicking the 1:1 button to show the image at its original size in pixels, or with the zoom fit button to set the zoom so the whole image is within the window. A dark theme is supported.

The image manipulation set includes resampling, flipping horizontally and vertically, and changing the canvas size, plus three operations that are less common: removing transparency fills the transparent pixels of the image, flattening reduces a layered image to one single layer, and a smart zoom by three resizes the image and detects borders, which the README says provides a useful zoom with ancient game sprites.

The community around it, and where the documentation lives

LazPaint is not a standalone project, and the README points at where the real documentation and discussion live rather than pretending the readme is enough.

The official sites are the LazPaint Wiki, the LazPaint forums on the Lazarus forum site, the Facebook page and a YouTube playlist. The wiki is the substantive one, and the features are organised there by area, with separate pages for files, tools, edit and select, the view windows, the command line, and the reference details for individual operations.

The split is sensible for a project of this size. The readme gives you the shape of the application and a list of what exists, and the wiki gives you how to use each of those things. A wiki is also editable by users, which is how a documentation set of this size stays current in a project with one primary maintainer.

The Lazarus connection is deeper than the toolkit. The forums are on the Lazarus forum, the compilation instructions are on the Lazarus wiki rather than in the repository, and the project exists because of the Lazarus community's help in getting it compiled on Windows, Linux, MacOS X, FreeBSD and the Raspberry Pi. LazPaint is a reasonable example of a small application that depends on an ecosystem rather than on a company, and the trade is that the platform coverage is genuinely wide while the support structure is informal.

The repository itself keeps the technical files in a few notable places. There is a lazpaint.logic file, which is the Pascal IDE project file, and a configure script with a configure.bat beside it for the Windows case. The commit.sh script and the prune_lpk directory handle the Lazarus package format, since a Lazarus application is distributed as an lpk, and the create_orig script appears to relate to the same packaging. The resources/ directory holds the scripts, icons and translation files that the Makefile copies into the installed tree, and the web/ directory is the project website source.

The licence is GPL-3.0 with a COPYING.txt at the root, which is the same copyleft the BGRABitmap library it is built on uses, and that is worth noting for anyone considering embedding it.

Colour adjustment, filters, renders and scriptable layer effects

The depth of the image processing is where this application is unlike the simple paint programs the name suggests.

The colour manipulation list runs to ten operations. Curves adjusts the curves for RGB and HSL channels separately, posterize reduces the number of colors by lightness or independently on each color channel, colorize sets the color of an image while preserving intensities, and shift colors cycles colors and changes colorness. Intensity makes colors lighter or darker without making them white while lightness does so by making them whiter, normalize uses the whole range of each color channel and the alpha channel, and there are two inversions, negative with gamma correction and linear negative without it, plus grayscale with gamma correction.

The filters can be applied to the whole image or to the active selection, which is a detail that matters more than it sounds. There is a radial blur that is non-directional, with box, gaussian and corona variants, a directional motion blur, and a custom blur that blurs according to a mask. Sharpen and Smooth are complements of each other, noise adds random pixel noise, and median computes the median of colors around each pixel, which softens corners. ClearType mimics the effect of TrueType font rendering, and an apply function operation applies any given function to any channel in RGB, HSL or Lab.

The drawing filters are more unusual: contour draws contours on a white background like a pencil drawing, emboss draws contours with shadow, a shaded map draws Phong highlights and shadows using a channel of the image as altitude, sphere applies a spherical projection, twirl distorts the image as a vortex, wave displacement distorts it as if reflected on waves, and cylinder applies a cylinder projection.

The render list generates images rather than editing them. Perlin noise produces a random image usable for nature-like randomness, with a cyclic variant that repeats. Water, snow print, wood, metal, stone and marble generate random textures, clouds add clouds of the current pen color, and rain adds rain falling with custom wind.

The layer effects are done via scripts, and that is a design choice with a consequence. Colour overlay replaces the color, drop shadow adds a shadow layer, inner light and inner shadow add a lighting layer depending on the border and therefore according to transparency, and stroke adds a layer to draw a stroke around the shape according to transparency. Because they are scripts rather than a compiled-in feature, they are open to the same scripting layer the application exposes, which is a different kind of extensibility from a plug-in API.

Editorial conclusion

LazPaint suits someone who wants a Paint.Net style editor that runs on a Raspberry Pi, a FreeBSD box or a Linux distribution package without an Electron download, and its filter and layer effect set is considerably wider than the name suggests. It does not suit you if you need a full professional package with a plug-in ecosystem, since the layer effects are provided by scripts rather than by a plugin API. Before you install, check the wiki entry for your platform, because the build system switches the widget toolkit per platform and the download page lists Windows, Mac and Linux binaries, and note that the primary language is Pascal rather than C, so any script you write for the layer effects is in a different ecosystem from most editors.

Frequently asked questions

Official sources

1. bgrabitmap/lazpaint on GitHub
2. License: GPL-3.0
3. Project website
4. README
5. Releases