# PainterEngine: A Self-Contained C Framework for Cross-Platform Graphics, Audio, and Embedded Systems

> PainterEngine is a C-language application and game engine with a software renderer, a script engine with a VM, signal processing, cryptography, and a neural network layer, all portable to any platform that can compile C, including bare-metal embedded targets.

**matrixcascade/PainterEngine** — PainterEngine is a application/game engine with software renderer,PainterEngine can be transplanted to any platform that supports C

- Repository: https://github.com/matrixcascade/PainterEngine
- Stars: 3,321 · Forks: 353
- Language: C
- License: MIT
- Published: 2026-09-24 · Updated: 2026-09-24 · Language: en
- Canonical page: https://hysenlabs.com/projects/matrixcascade-painterengine

## What PainterEngine is for and who uses it

PainterEngine is a C-language graphics and application framework with a software renderer. It runs on Windows, Linux, iOS, Android, WebAssembly, HarmonyOS, and bare-metal embedded systems with no operating system. The software renderer is the core design choice: because it does not rely on GPU hardware acceleration, it works on any platform that can compile C and allocate memory, including microcontrollers and FPGA-based SoCs.

The README positions it both as a tool for building applications and as a learning project. The feature table covers eighteen categories: memory pool, math library, signal processing, data structures, cryptography, neural networks, image codecs, audio codecs, font support, geometry rendering, a 2D and 3D renderer, animation, an acoustics model, a script engine, a UI framework, network protocols, a game engine framework, a cross-platform display server, and an FPGA-GPU design. That breadth is the defining characteristic of PainterEngine. It is not a thin graphics API; it is a complete application development environment in C.

The project website is painterengine.com. The last push to the repository was on 2026-09-22.

## The single-header integration and component-based design

Adding PainterEngine to a project requires one include statement:

```c
#include "PainterEngine.h"
```

The simplest possible program creates an 800 by 600 window:

```c
#include "PainterEngine.h"
int main()
{
    PainterEngine_Initialize(800, 600);
    return 1;
}
```

Components are the building block of a PainterEngine application. The framework provides pre-built components and the README shows how to instantiate them. The following example creates three firework components at different horizontal positions:

```c
#include "PainterEngine.h"
int main()
{
    PainterEngine_Initialize(800, 600);
    PX_Object_Firework01Create(mp, root,200,600);
    PX_Object_Firework01Create(mp, root,400,600);
    PX_Object_Firework01Create(mp, root,600,600);
    return 1;
}
```

The function naming convention shows the component system: PX_Object_ prefixes component constructors. The mp and root parameters are the memory pool and scene root, which PainterEngine_Initialize sets up.

For projects not using PainterEngine Make, manual integration requires adding the core/, kernel/, and runtime/ directories to the project, then adding the appropriate directory from platform/ (for example, platform/windows for Windows), and then adding the PainterEngine installation directory to the include paths. The repository root contains a CMakeLists.txt for teams using CMake.

## PainterEngine Make: one-click multi-platform compilation

PainterEngine Make is a separate desktop tool available as a download from painterengine.com. It provides one-click compilation of a PainterEngine project to Windows, Linux, WebAssembly, and Android without modifying the source code. The README states zero-cost porting with no source modification required between platforms.

This is the primary workflow for developers who want to distribute their application on multiple platforms without setting up individual build systems for each target. A project developed and tested on Windows can be compiled to WebAssembly for browser delivery and to Android for mobile through the same tool.

For teams that prefer their own IDE and build system, PainterEngine Make is optional. The manual integration path described above works with any C compiler that can process the source files and include directories. The repository root contains a CMakeLists.txt for teams using CMake, which is the standard build system integration path for projects that manage their own toolchain.

The platform/ directory in the repository contains platform-specific adapter code for each supported target. When porting to a new platform, the developer writes the adapter for that target in platform/, implementing the display, input, and timer interfaces that the core engine expects. This is the contract that makes bare-metal embedded porting possible: the core engine code is platform-agnostic, and only the adapter layer needs to be written per target.

## The built-in codec and algorithm library

PainterEngine includes a substantial library of algorithms that eliminates the need for common external dependencies. The math library provides a full C standard math implementation covering sin, cos, tan, arcsin, log, exp, and relu among others. The data structure library includes string, vector, list, map, stack, fifo, and circular-buffer, all implemented as platform-independent C code.

The image codec layer handles PNG decoding and encoding, plus JPG, GIF, and BMP decoding. Audio support covers WAV and MP3 decoding and WAV encoding. Font rendering uses TTF files via a port of stb_truetype.c. These standard building blocks mean a PainterEngine application does not need libpng, libjpeg, or a separate math library, which matters greatly on embedded targets where including those libraries may be impractical.

The signal processing module covers the DFT, DCT, FFT, DWT, common window functions, and MFCC feature extraction. These are the standard algorithms for audio analysis, speech feature extraction, and digital filter design. The cryptography module includes Curve25519 for key agreement, AES for symmetric encryption, SHA-family hash functions, and MD5. The neural network module implements a backpropagation (BP) neural network for simple classification tasks.

The geometry rendering module covers line, triangle, rectangle, circle, ring, sector, and rounded shapes as common rasterization primitives. The 2D and 3D renderer layer sits above that, providing a high-quality drawing engine. The animation module handles 2dx format 2D animations and a skeleton animation system with similarities to the Live2D approach. The UI framework provides standard widget types: buttons, radio buttons, image components, editable text fields, labels, and list views. The game engine integrates a world framework on top of the component system. Together, these layers mean the same C codebase can power an industrial SCADA panel, an embedded instrument display, and a lightweight 2D game without switching frameworks.

## The script engine, acoustics model, and network protocols

The script engine is a complete implementation: a compiler, a virtual machine, and a debugger. This means PainterEngine applications can load and run scripts without leaving the framework, which is valuable for embedded systems where adding a scripting runtime from another library would require significant porting work.

The acoustics model is an unusual inclusion for a graphics framework. It contains a software audio mixer, a phase vocoder, a physically modeled piano, and Karplus-Strong synthesis for plucked string sounds. These are implemented in C and generate PCM audio streams directly.

The protocol layer covers MQTT for IoT messaging, MODBUS for industrial hardware communication, and a game network synchronization protocol. These three protocols address the hardware and embedded use cases that distinguish PainterEngine from a typical desktop game framework.

For embedded targets with no display hardware, the VisualOS component provides a TCP-network-based display server. An application running on a device without a screen connects to a remote viewer over the network. The README describes this as enabling CS/BS (client-server/browser-server) architecture remote UI interaction, giving a graphical terminal to devices that otherwise have no display path.

## FPGA-GPU support, SDL2 comparison, and license

PainterEngine includes an FPGA-based GPU IP core for hardware-accelerated 2D rendering. The README states it has been verified on the Zynq7020 SoC and provides at least 50 million pixels per second of 2D blending acceleration with HDMI output support. This is an FPGA hardware design that accelerates PainterEngine's software renderer on FPGA-equipped embedded hardware, targeting the Zynq7000 series SoC family.

PainterEngine uses a software renderer by default. On hardware where a GPU is available, a library that targets OpenGL, Vulkan, or Metal will be faster for 3D rendering tasks. PainterEngine makes an explicit trade-off: portability and self-containment over hardware-accelerated 3D performance.

SDL2 is the most common comparison point for a C cross-platform multimedia library. SDL2 provides window management, input handling, 2D rendering using hardware acceleration when available, and audio output. It does not include signal processing, cryptography, a scripting VM, a neural network layer, MQTT, MODBUS, or an FPGA GPU design. SDL2 is the right choice when you need a thin, battle-tested layer over platform native multimedia APIs with hardware acceleration. PainterEngine is the right choice when you need the additional modules it bundles, especially for embedded and FPGA targets.

The MIT license allows use in commercial and proprietary products without source disclosure requirements.

## Conclusion

PainterEngine is the right choice for embedded systems engineers who need graphics, audio, scripting, and networking in a single portable C library with no OS dependency. It is also a study project for developers who want to see how rendering, signal processing, cryptography, and a scripting VM are implemented from scratch in C. Teams building standard desktop games or applications with GPU-accelerated 3D rendering should use a library that targets a hardware graphics API directly. Check the platform/ directory to confirm your target platform has a pre-written adapter before designing the project around PainterEngine, because porting to an unsupported bare-metal environment requires writing that adapter yourself.

## FAQ

### Can PainterEngine run on a microcontroller or embedded system without an operating system?

Yes. The README explicitly lists bare-metal embedded platforms as a supported target. The software renderer means there is no dependency on a GPU driver, and the platform/ directory contains adapters for supported environments. The VisualOS TCP display server can provide a remote graphical interface to devices without a screen.

### Does PainterEngine require any external libraries or dependencies?

The README describes PainterEngine as self-contained. The feature table covers data structures, math, signal processing, cryptography, image codecs, audio codecs, UI, and networking within the C codebase. The TTF font module is ported from stb_truetype.c. Integration requires only adding the core/, kernel/, runtime/, and platform/ directories and a single include path.

### What is the PainterEngine script engine?

The script engine is a complete implementation inside PainterEngine: a compiler, a virtual machine, and a debugger, all written in C. It is listed in the feature table and allows PainterEngine applications to load and execute scripts at runtime without integrating an external scripting language.

## Sources

- [Issues](https://github.com/matrixcascade/PainterEngine/issues)
- [License: MIT](https://github.com/matrixcascade/PainterEngine/blob/master/LICENSE)
- [matrixcascade/PainterEngine on GitHub](https://github.com/matrixcascade/PainterEngine)
- [README](https://github.com/matrixcascade/PainterEngine/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/matrixcascade-painterengine