Current development documentation | Source snapshot: 2026-07-30

SimpleFPEWrapper (SFPEW) is an OpenGL compatibility wrapper, not a replacement driver. An application obtains its GL and selected EGL entry points from SFPEW; the wrapper preserves a desktop-oriented API surface, emulates fixed-function behavior with generated programmable shaders, translates legacy GLSL, and finally calls the GL implementation already current through EGL.

The project is aimed at programs that mix old OpenGL 1.x/2.1-style rendering with newer programmable rendering, especially legacy Java/LWJGL consumers. The backend contract is deliberately narrow: OpenGL ES 3.0+ or desktop OpenGL 3.2+. SFPEW does not create or select that context; its host does.

Start here

Goal	Page
Build the shared library and run its tests	Getting Started
Integrate SFPEW with an existing EGL host	EGL Host Integration
Look up every resolver-returned symbol	API Reference
Understand which layer owns a call or state	Architecture
Understand the resolver and EGL interception boundary	Interposition & Dispatch
Follow fixed-function state into a generated draw	Fixed-Function Emulator
Trace immediate mode, client arrays, VBOs and display lists	Legacy Draw Paths
Understand GLSL translation and mixed user-program draws	Shader Compatibility
Check backend requirements and guarded entry points	Backend Profile
See the supported surface and known limits	Capabilities & Limits
Run smoke, Piglit and static contract checks	Validation & Diagnostics
Diagnose loading, context, shader and rendering failures	Troubleshooting

What SFPEW contains

1. Interposition surface: lookup.cpp, exported entry points and eglGetProcAddress/GLX resolver aliases decide whether a call is wrapped or forwarded.
2. Backend loader: backend/loader.* opens EGL and builds a function table from eglGetProcAddress; it deliberately does not link to a specific GL or GLES implementation.
3. Context-local compatibility state: fpe/types.h, fpe/fpe.cpp, state/query code and logical shadows retain the legacy state that ES/GL core no longer exposes.
4. Fixed-function rendering: fpe/fpe_shadergen.cpp, fpe/glstate.cpp, vertex-pointer code and drawing1x.cpp turn legacy state and vertices into backend shader programs, VAOs and buffers.
5. Programmable compatibility: shader/* translates old shader source and feeds compatibility uniforms/attributes to application-owned programs when needed.
6. Boundary adapters: draw, getter, FBO, pixel, selection/evaluator and display-list code handle API forms that cannot simply be sent to an ES backend unchanged.

The common path is:

application / LWJGL
  -> SFPEW exported symbol or eglGetProcAddress result
  -> entry barrier + context-local logical state
  -> fixed-function conversion, shader translation, or ordered passthrough
  -> function pointer obtained from the current EGL implementation
  -> GLES 3 / desktop GL backend

Important boundary

SFPEW is intentionally coexistence-oriented. It uses its own VAOs, VBOs, EBOs and generated programs, then returns observable bindings to the application before an entry point can expose or change them. This isolation is essential when legacy geometry, translated shaders and native user programs appear in the same frame; it also means some client-memory paths must upload data before drawing.

The API resolver currently records 529 names in the checked-in API Reference. A resolvable name is an ABI promise only; feature behavior and gaps are described in Capabilities & Limits.

Status and maintenance

This is development documentation for the source snapshot dated 2026-07-30, not a release certification or a compatibility guarantee. Project Status defines that boundary, Changelog records documentation changes, and Contributing defines how source and documentation snapshots move together.

License

The source tree is distributed under GNU LGPL v3.0. Bundled third-party projects keep their respective upstream licenses.