- 1 General
- 2 Hardware
- 3 VBIOS
- 4 Display standards
- 5 Framebuffer
- 6 Display server
- 7 X Window System
- 8 Mir
- 9 Arcan
- 10 Graphics APIs
- 11 EGL
- 12 Engine
- 13 to sort
- 14 Graphic designers
- 15 Graffiti
- 16 Testing
- LWN.net: A new direction for i965
- https://en.wikipedia.org/wiki/Video_BIOS - the BIOS of a graphics card in a (usually IBM PC-derived) computer. Much the way the system BIOS provides a set of functions that are used by software programs to access the system hardware, the video BIOS provides a set of video-related functions that are used by programs to access the video hardware. The video BIOS interfaces software to the video chipset in the same way that the system BIOS does for the system chipset. The ROM also contained a basic font set to upload to the video adapter font RAM, if the video card did not contain a font ROM with this font set instead.
- https://en.wikipedia.org/wiki/VESA_BIOS_Extensions - a VESA standard, currently at version 3, that defines the interface that can be used by software to access compliant video boards at high resolutions and bit depths. This is opposed to the "traditional" int 10h BIOS calls, which are limited to resolutions of 640×480 pixels with 16 color (4-bit) depth or less. VBE is made available through the video card's BIOS, which installs during boot up some interrupt vectors that point to itself.
Most newer cards implement the more capable VBE 3.0 standard. Older versions of VBE provide only a real mode interface, which cannot be used without a significant performance penalty from within protected mode operating systems. Consequently, the VBE standard has almost never been used for writing a video card's drivers; each vendor has thus had to invent a proprietary protocol for communicating with its own video card. Despite this, it is common that a driver thunk out to the real mode interrupt in order to initialize screen modes and gain direct access to a card's linear frame buffer, because these tasks would otherwise require handling many hundreds of proprietary variations that exist from card to card.
- https://en.wikipedia.org/wiki/Color_Graphics_Adapter - originally also called the Color/Graphics Adapter or IBM Color/Graphics Monitor Adapter, introduced in 1981, was IBM's first graphics card and first color display card for the IBM PC. For this reason, it also became that computer's first color computer display standard.The standard IBM CGA graphics card was equipped with 16 kilobytes of video memory and could be connected either to a dedicated direct-drive CRT monitor using a 4-bit digital (TTL) RGBI interface, such as the IBM 5153 color display, or to an NTSC-compatible television or composite video monitor via an RCA connector. The RCA connector provided only baseband video, so to connect the CGA card to a standard television set required a separate RF modulator unless the TV had an RCA jack, although doing so with the former combined with an amplifier was sometimes more practical, since one could then hook up an antenna to the amplifier and get wireless video.
- https://en.wikipedia.org/wiki/VGA-compatible_text_mode - introduced in 1987 by IBM as part of the VGA standard for its IBM PS/2 computers. Its use on IBM PC compatibles was widespread through the 1990s and persists today for some applications on modern desktop computers. The main features of VGA text mode are colored (programmable 16 color palette) characters and their background, blinking, various shapes of the cursor (block/underline/hidden static/blinking), and loadable fonts (with various glyph sizes). The Linux console traditionally uses hardware VGA-compatible text modes, and the Win32 console environment has an ability to switch the screen to text mode for some text window sizes.
- https://en.wikipedia.org/wiki/Super_VGA - or Ultra VGA, or just SVGA or UVGA, short for Super Video Graphics Array and Ultra Video Graphics Array is a broad term that covers a wide range of computer display standards. The SVGA standard was developed in 1988, when NEC Home Electronics announced its creation of the Video Electronics Standards Association (VESA). The development of SVGA was led by NEC, along with other VESA members including ATI Technologies and Western Digital. SVGA enabled graphics display resolutions up to 800×600 pixels, 56% more pixels than VGA's maximum resolution of 640×480.
- https://en.wikipedia.org/wiki/Mode_setting - a software operation that activates a display mode (screen resolution, colour depth, and refresh rate) for a computer's display controller.In kernel mode-setting (KMS), the display mode is set by the kernel. In user-space mode-setting (UMS), the display mode is set by a userland process. Kernel mode-setting is more flexible and allows displaying of an error in the case of a fatal system error in the kernel, even when using a user-space display server.User-space mode setting would require superuser privileges for direct hardware access, so kernel-based mode setting shuns such requirement for the user-space graphics server.
- https://wiki.archlinux.org/index.php/Kernel_mode_setting - a method for setting display resolution and depth in the kernel space rather than user space.The Linux kernel's implementation of KMS enables native resolution in the framebuffer and allows for instant console (tty) switching. KMS also enables newer technologies (such as DRI2) which will help reduce artifacts and increase 3D performance, even kernel space power-saving.
- https://en.wikipedia.org/wiki/Framebuffer - frame buffer, or sometimes framestore, is a portion of RAM containing a bitmap that drives a video display. It is a memory buffer containing a complete frame of data. Modern video cards contain framebuffer circuitry in their cores. This circuitry converts an in-memory bitmap into a video signal that can be displayed on a computer monitor.
In computing, a screen buffer is a part of computer memory used by a computer application for the representation of the content to be shown on the computer display. The screen buffer may also be called the video buffer, the regeneration buffer, or regen buffer for short. Screen buffers should be distinguished from video memory. To this end, the term off-screen buffer is also used.
The information in the buffer typically consists of color values for every pixel to be shown on the display. Color values are commonly stored in 1-bit binary (monochrome), 4-bit palettized, 8-bit palettized, 16-bit high color and 24-bit true color formats. An additional alpha channel is sometimes used to retain information about pixel transparency. The total amount of memory required for the framebuffer depends on the resolution of the output signal, and on the color depth or palette size.
- https://en.wikipedia.org/wiki/Linux_framebuffer - fbdev is a graphic hardware-independent abstraction layer to show graphics on a computer monitor, typically on the console. The word framebuffer means a part of video memory containing a current video frame, and the Linux framebuffer means “access method to the framebuffer under the Linux kernel”, without relying on system-specific libraries such as SVGALib or another user space software.
- https://github.com/numbqq/glmark2-es2-fbdev - glmark2-es2 for ARM Mali GPU fbdev mode
- fbsplash - formerly gensplash, is a userspace implementation of a splash screen for Linux systems. It provides a graphical environment during system boot using the Linux framebuffer layer.
Q: "I get a tty1 login before KDM pops up." A: "You could disable tty1. Comment out this line in /etc/inittab: c1:2345:respawn:/sbin/agetty -8 38400 tty1 linux"
- directfb.net - a thin library that provides hardware graphics acceleration, input device handling and abstraction, integrated windowing system with support for translucent windows and multiple display layers, not only on top of the Linux Framebuffer Device. It is a complete hardware abstraction layer with software fallbacks for every graphics operation that is not supported by the underlying hardware. DirectFB adds graphical power to embedded systems and sets a new standard for graphics under Linux. 
- fbv - a very simple graphic file viewer for the framebuffer console, capable of displaying GIF, JPEG, PNG and BMP files using libungif, libjpeg, and libpng. The image can be shown either in fit-to-screen or panning mode in 8, 15/16, and 32bpp.
- https://wiki.mozilla.org/Mobile/DFBPorting - unning with full functionality (including SVG) on DirectFB (web site, Wikipedia) -based platforms
- SVGAlib Tutorials - provides an easy way to create graphical applications and eliminates the rigmarole of the X Window System. If you have even the most rudimentary grasp of programming in C, then you can use SVGAlib.
- Using GTK+ on the Framebuffer - Using GTK+ on the Framebuffer — Linux framebuffer aspects of using GTK+
- Xvfb - or X virtual framebuffer is a display server implementing the X11 display server protocol. In contrast to other display servers Xvfb performs all graphical operations in memory without showing any screen output. From the point of view of the client, it acts exactly like any other X display server, serving requests and sending events and errors as appropriate. However, no output is shown. This virtual server does not require the computer it is running on to even have a screen or any input device. Only a network layer is necessary. Unlike a real display server, Xvfb does not support modern X11 extensions like compositing, Randr or GLX. Xdummy is a newer alternative which supports these extensions as well as providing the same functionality as Xvfb. Xvfb is primarily used for testing.
- fbturbo - an Xorg driver for Allwinner and other ARM-based devices, derived from fbdev driver. With regard to 2D graphics, it provides a number of software optimizations on all platforms, while letting the SIMD (ARM NEON) accelerated code from the pixman library run at full speed without any unnecessary overhead. 2D hardware acceleration using G2D is supported on sunxi platforms. The recommended framebuffer color depths are 16 (RGB565) and 24 (XRGB8888), the other color depths may be supported too. Multi-head configurations are supported.
- https://github.com/emoon/minifb - a small cross platform library that makes it easy to render (32-bit) pixels in a window.
- https://wiki.archlinux.org/index.php/AMD_Catalyst - AMD's Linux driver package catalyst was previously named fglrx (FireGL and Radeon X). Only the package name has changed, while the kernel module retains its original fglrx.ko filename. Therefore, any mention of fglrx below is specifically in reference to the kernel module, not the package.
- https://github.com/notro/fbtft - Linux Framebuffer drivers for small TFT LCD display modules
- https://github.com/emoon/minifb - MiniFB (Mini FrameBuffer) is a small cross platform library that makes it easy to render (32-bit) pixels in a window. An example is the best way to show how it works:
- DDX - For each type of graphics card there is a Device Dependent X (DDX) driver which does initialization, manages the display and performs 2D rendering. XFree86 4.0 introduced a new device driver interface called XAA which should allow XFree86 drivers to be backward compatible with future versions of the X server. Each 2D driver has a bit of code to bootstrap the 3D / DRI features.
DRM / DRI
- https://en.wikipedia.org/wiki/Direct_Rendering_Manager - a subsystem of the Linux kernel responsible for interfacing with GPUs of modern video cards. DRM exposes an API that user space programs can use to send commands and data to the GPU, and perform operations such as configuring the mode setting of the display. DRM was first developed as the kernel space component of the X Server's Direct Rendering Infrastructure, but since then it has been used by other graphic stack alternatives such as Wayland. User space programs can use the DRM API to command the GPU to do hardware accelerated 3D rendering, video decoding as well as GPGPU computing.
- https://github.com/ascent12/drm_doc - an ongoing series of articles describing how to use the Linux DRM API.
echo 0xff | sudo tee /sys/module/drm/parameters/debug # and echo 0x00 | sudo tee /sys/module/drm/parameters/debug
- https://en.wikipedia.org/wiki/Direct_Rendering_Infrastructure - a framework for allowing direct access to graphics hardware under the X Window System in a safe, efficient way. The main use of DRI is to provide hardware acceleration for the Mesa implementation of OpenGL. DRI has also been adapted to provide OpenGL acceleration on a framebuffer console without a display server running. DRI implementation is scattered through the X Server and its associated client libraries, Mesa 3D and the Direct Rendering Manager kernel subsystem.
- https://en.wikipedia.org/wiki/Display_server - or window server is a program whose primary task is to coordinate the input and output of its clients to and from the rest of the operating system, the hardware, and each other. The display server communicates with its clients over the display server protocol, a communications protocol, which can be network-transparent or simply network-capable. The display server is a key component in any graphical user interface, specifically the windowing system.
X Window System
- Arcan - Arcan is a powerful development framework for creating virtually anything between user interfaces for specialised embedded applications all the way to full-blown standalone desktop environments. Boot splash screen? no problem. SCADA HMI for your home? easy peasy. Xorg backend? got you covered. Wayland compositor? sure thing. At its heart lies a robust and portable multimedia engine, with a well-tested and well-documented interface, programmable using Lua. At every step of the way, the underlying development emphasises security, performance and debugability guided by a principle of least surprise in terms of API design. 
- Durden - a desktop environment for the Arcan Display Server. It serves both as a reference showcase on how to take advantage of some of the features in Arcan, and as a very competent entry to the advanced-user side of the desktop environment spectrum. The basic premise is to absorb most, if not all, features from current desktop environments in a modular and configurable way - then let user selected profiles actually cherry- pick the configuration, visuals and tunning that reflects the desktop the user wants or is familiar with. Internally, it is based around a file-system like structure ("the menu") and everything else is references to paths within this structure. Development is discussed on IRC @ irc.freenode.net, #arcan - while issues are tracked at the github page for now.
- https://github.com/letoram/prio - pRio - Plan9- Rio like Window Manager for Arcan
- https://github.com/mikesart/gpuvis - GPU Trace Visualizer
- platform/external/deqp - Git at Google - a GPU testing suite called dEQP (drawElements Quality Program). dEQP contains tests for several graphics APIs, including OpenGL ES, EGL, and Vulkan.
- Mesa - began as an open-source implementation of the OpenGL specification - a system for rendering interactive 3D graphics.Over the years the project has grown to implement more graphics APIs, including OpenGL ES (versions 1, 2, 3), OpenCL, OpenMAX, VDPAU, VA API, XvMC and Vulkan.A variety of device drivers allows the Mesa libraries to be used in many different environments ranging from software emulation to complete hardware acceleration for modern GPUs.Mesa ties into several other open-source projects: the Direct Rendering Infrastructure and X.org to provide OpenGL support on Linux, FreeBSD and other operating systems.
- Gallium3D - is Tungsten Graphics' new architecture for building 3D graphics drivers. Initially supporting Mesa and Linux graphics drivers, Gallium3D is designed to allow portability to all major operating systems and graphics interfaces.
- OpenGL - "The Industry Standard for High Performance Graphics"
- Learn OpenGL - "Welcome to my humble attempt to facilitate a well-developed teaching platform for the graphics API called OpenGL. Whether you are trying to learn OpenGL for academic purposes, to pursue a career or simply looking for a hobby, this site will teach you the basics, the intermediate and all the advanced knowledge using modern (core-profile) OpenGL. The aim of LearnOpenGL is to show you all there is to modern OpenGL in an easy-to-understand fashion with clear examples, while also providing a useful reference for later studies."
- https://en.wikipedia.org/wiki/EGL_(API) - an interface between Khronos rendering APIs (such as OpenGL, OpenGL ES or OpenVG) and the underlying native platform windowing system. EGL handles graphics context management, surface/buffer binding, rendering synchronization, and enables "high-performance, accelerated, mixed-mode 2D and 3D rendering using other Khronos APIs." EGL is managed by the non-profit technology consortium Khronos Group.
- https://en.wikipedia.org/wiki/OpenGL_Utility_Library - 'GLU, a computer graphics library for OpenGL.It consists of a number of functions that use the base OpenGL library to provide higher-level drawing routines from the more primitive routines that OpenGL provides. It is usually distributed with the base OpenGL package. GLU is not implemented in the embedded version of the OpenGL package, OpenGL ES. Among these features are mapping between screen- and world-coordinates, generation of texture mipmaps, drawing of quadric surfaces, NURBS, tessellation of polygonal primitives, interpretation of OpenGL error codes, an extended range of transformation routines for setting up viewing volumes and simple positioning of the camera, generally in more human-friendly terms than the routines presented by OpenGL. It also provides additional primitives for use in OpenGL applications, including spheres, cylinders and disks.
- GLM - a header only C++ mathematics library for graphics software based on the OpenGL Shading Language (GLSL) specifications. GLM provides classes and functions designed and implemented with the same naming conventions and functionalities than GLSL so that anyone who knows GLSL, can use GLM as well in C++. This project isn't limited to GLSL features. An extension system, based on the GLSL extension conventions, provides extended capabilities: matrix transformations, quaternions, data packing, random numbers, noise, etc... This library works perfectly with OpenGL but it also ensures interoperability with other third party libraries and SDK. It is a good candidate for software rendering (raytracing / rasterisation), image processing, physic simulations and any development context that requires a simple and convenient mathematics library.
- OpenGL Extension - a means for OpenGL implementations to provide new or expanded functionality that the core of OpenGL does not provide. Using extensions should not be looked on as something to be avoided; it should be accepted as standard practice for the OpenGL user.Some extensions expose features that only one particular hardware vendor exposes, but many extensions are implemented by multiple implementations. There is a mechanism for determining which extensions are available from a particular implementation.
- GLEW - a cross-platform open-source C/C++ extension loading library. GLEW provides efficient run-time mechanisms for determining which OpenGL extensions are supported on the target platform. OpenGL core and extension functionality is exposed in a single header file. GLEW has been tested on a variety of operating systems, including Windows, Linux, Mac OS X, FreeBSD, Irix, and Solaris.
- OpenGL SDK - GLee
- OpenGL Extensions Viewer - A reliable software which displays useful information about the current OpenGL 3D accelerator and new Vulkan 3D API. This program displays the vendor name, the version implemented, the renderer name and the extensions of the current OpenGL 3D accelerator.
- https://github.com/cginternals/glbinding - leverages C++11 features like enum classes, lambdas, and variadic templates, instead of relying on macros; all OpenGL symbols are real functions and variables. It provides type-safe parameters, per feature API header, lazy function resolution, multi-context and multi-thread support, global and local function callbacks, meta information about the generated OpenGL binding and the OpenGL runtime, as well as tools and examples for quick-starting your projects. Based on the OpenGL API specification (gl.xml) glbinding is generated using python scripts and templates that can be easily adapted to fit custom needs.
- https://github.com/anholt/libepoxy - Epoxy is a library for handling OpenGL function pointer management for you
- https://github.com/skaslev/gl3w - Simple OpenGL core profile loading
- https://github.com/rikusalminen/glxw - OpenGL loader and dynamic linker
- glad - Multi-Language GL/GLES/EGL/GLX/WGL Loader-Generator based on the official specs.
- GLUT - The OpenGL Utility Toolkit. "We direct you to use FreeGLUT found on SourceForge: http://freeglut.sourceforge.net/. The original GLUT has been unsupported for 20 years."
- freeglut - a free-software/open-source alternative to the OpenGL Utility Toolkit (GLUT) library. GLUT was originally written by Mark Kilgard to support the sample programs in the second edition OpenGL 'RedBook'. Since then, GLUT has been used in a wide variety of practical applications because it is simple, widely available and highly portable.GLUT (and hence FreeGLUT) takes care of all the system-specific chores required for creating windows, initializing OpenGL contexts, and handling input events, to allow for trully portable OpenGL programs.FreeGLUT is released under the X-Consortium license.
- GLFW - an Open Source, multi-platform library for OpenGL, OpenGL ES and Vulkan development on the desktop. It provides a simple API for creating windows, contexts and surfaces, receiving input and events. GLFW is written in C and has native support for Windows, macOS and many Unix-like systems using the X Window System, such as Linux and FreeBSD.GLFW is licensed under the zlib/libpng license.
- Pugl - a minimal portable API for GUIs which supports embedding and is suitable for use in plugins. It works on X11, Mac OS X, and Windows. GUIs can be drawn with OpenGL or Cairo. Pugl is vaguely similar to GLUT, but with some significant distinctions: Minimal in scope, providing only what is necessary to draw and receive keyboard and mouse input. No reliance on static data whatsoever, so the API can be used in plugins or multiple independent parts of a program. Single implementation, which is small, liberally licensed Free / Open Source Software, and suitable for direct inclusion in programs if avoiding a library dependency is desired. Support for embedding in other windows, so Pugl code can draw to a widget inside a larger GUI. More complete support for keyboard input, including additional "special" keys, modifiers, and support for detecting individual modifier key presses.
- CmdlineGL - a simple binary that reads a stream of OpenGL commands as text, renders them to an X11 window, and then writes any user input from the window to standard out. It enables any language capable of reading and writing text to then be able to build interactive graphical applications. This is an old project I wrote in college. It was my 6th entry in a series of "Abuse of Technology" projects where I would do something absurd that was also sort of cool or intriguing or surprising that it could even work. In this case, I was writing animated OpenGL demos in Bash, though it can be used in conjunction with any language.
- OpenGL bindings for Bash - A project that started as a joke can be useful to people wanting to learn the concepts of OpenGL.
- https://en.wikipedia.org/wiki/VirtualGL - an open source program that redirects the 3D rendering commands from Unix and Linux OpenGL applications to 3D accelerator hardware in a dedicated server and displays the rendered output interactively to a thin client located elsewhere on the network.
- Piglit - an open-source test suite for OpenGL implementations.
- https://www.khronos.org/opengl/wiki/Image_Libraries - Loading images from files is outside the scope of the OpenGL specification. It is handled by user-made code or one of the image handling libraries below.
- lonesock.net: SOIL - a tiny C library used primarily for uploading textures into OpenGL. It is based on stb_image version 1.16, the public domain code from Sean Barrett (found here). I have extended it to load TGA and DDS files, and to perform common functions needed in loading OpenGL textures. SOIL can also be used to save and load images in a variety of formats (useful for loading height maps, non-OpenGL applications, etc.)
- https://en.wikipedia.org/wiki/OpenVG - an API designed for hardware-accelerated 2D vector graphics. Its primary platforms are mobile phones, gaming & media consoles and consumer electronic devices. It was designed to help manufacturers create more attractive user interfaces by offloading computationally intensive graphics processing from the CPU onto a GPU to save energy. OpenVG is well suited to accelerating Flash and mobile profile of SVG sequences. The OpenGL ES library provides similar functionality for 3D graphics. OpenVG is managed by the non-profit technology consortium Khronos Group.
- https://en.wikipedia.org/wiki/OpenGL_ES - or GLES is a subset of the OpenGL computer graphics rendering application programming interface (API) for rendering 2D and 3D computer graphics such as those used by video games, typically hardware-accelerated using a graphics processing unit (GPU). It is designed for embedded systems like smartphones, tablet computers, video game consoles and PDAs. OpenGL ES is the "most widely deployed 3D graphics API in history". The API is cross-language and multi-platform. The libraries GLUT and GLU are not available for OpenGL ES. OpenGL ES is managed by the non-profit technology consortium Khronos Group. Vulkan, a next-generation API from Khronos, is made for simpler high performance drivers for mobile and desktop devices.
- https://github.com/brackeen/glfm - Write OpenGL ES code in C/C++ without writing platform-specific code.GLFM is an OpenGL ES layer for mobile devices and the web. GLFM supplies an OpenGL ES context and input events. It is largely inspired by GLFW.GLFM is written in C and runs on iOS 8, tvOS 9, Android 2.3.3 (API 10), and WebGL 1.0 (via Emscripten).
- https://github.com/lunixbochs/glshim - a shim providing OpenGL 1.x functionality to OpenGL ES accelerated cards.
- https://github.com/lunixbochs/tinygles - a software OpenGL ES driver, intended for use with glshim.
- GL4ES - a library provide OpenGL 2.x functionality for GLES2.0 accelerated Hardware (and support OpenGL 1.5 function, sometimes better then when using GLES 1.1 backend) There is also support for GLES 1.1 Hardware, emulating OpenGL 1.5, and some OpenGL 2.x+ extensions.GL4ES is known to work on many platform: OpenPandora, ODroid, RaspberryPI (2 and 3 at least), PocketCHIP, “otherfruit”PI (like the OrangePI), Android, x86 and x86_64 Linux (tested using mesa-egl). There is also some WIP support for AmigaOS4, using experimental GLES2 driver for Warp3D. The focus is on compatibility and speed with a wide selection of game and software.It has been tested successfully of a large selection of games and software, including: Minecraft, OpenMW, SeriousSam (both First and Second Encounters), RVGL (ReVolt GL), TSMC (The Secret Maryo Chronicles), TORCS, SpeedDreams, GL-117, Foobillard(plus), Blender 2.68 to name just a few.
- Vulkan - a new generation graphics and compute API that provides high-efficiency, cross-platform access to modern GPUs used in a wide variety of devices from PCs and consoles to mobile phones and embedded platforms.
- https://en.wikipedia.org/wiki/EGL_(API) - an interface between Khronos rendering APIs (such as OpenGL, OpenGL ES or OpenVG) and the underlying native platform windowing system. EGL handles graphics context management, surface/buffer binding, rendering synchronization, and enables "high-performance, accelerated, mixed-mode 2D and 3D rendering using other Khronos APIs." EGL is managed by the non-profit technology consortium Khronos Group.The acronym EGL is an initialism, which starting from EGL version 1.2 refers to Khronos Native Platform Graphics Interface. Prior to version 1.2, the name of the EGL specification was OpenGL ES Native Platform Graphics Interface. X.Org development documentation glossary defines EGL as "Embedded-System Graphics Library"
- Skia Graphics Library - an open source 2D graphics library which provides common APIs that work across a variety of hardware and software platforms. It serves as the graphics engine for Google Chrome and Chrome OS, Android, Mozilla Firefox and Firefox OS, and many other products. Skia is sponsored and managed by Google, but is available for use by anyone under the BSD Free Software License. While engineering of the core components is done by the Skia development team, we consider contributions from any source.
- https://github.com/blend2d/blend2d - 2D Vector Graphics Powered by a JIT Compiler.
- https://en.wikipedia.org/wiki/Color_space - a specific organization of colors. In combination with physical device profiling, it allows for reproducible representations of color, in both analog and digital representations. A color space may be arbitrary, with particular colors assigned to a set of physical color swatches and corresponding assigned color names or numbers (such as with the Pantone collection), or structured mathematically (as with the NCS System, Adobe RGB and sRGB).
- https://en.wikipedia.org/wiki/Color_model - an abstract mathematical model describing the way colors can be represented as tuples of numbers (e.g. triples in RGB or quadruples in CMYK); however, a color model with no associated mapping function to an absolute color space is a more or less arbitrary color system with no connection to any globally understood system of color interpretation.
- https://en.wikipedia.org/wiki/HSLuv - a human-friendly alternative to the HSL color space. It was formerly known as "husl".
- HSLuv - a developer friendly perceptual color space.
- The importance of good noise - There are many articles to read about noise functions in computer graphics, especially now that a lot of people recently got interested in ray tracing, but it took me a long time to fully understood why noise characteristics are so important and I didn’t find a good resource on the Internet explaining it, so I’ll give it a shot.
- Glitch Art with SoX, ImageMagick, and Vim | Blog | Mary Knize
- https://github.com/TotallyNotChase/glitch-this - Glitchify static images to glitched images and GIFs!
- YouTube: More Like This, Please! Texture Synthesis and Remixing from a Single Example | Nordic Game 2019
- EbSynth brings art to life with 2D motion capture - Fast Example-based Image Synthesis and Style Transfer
Context Free Art
- Context Free Art - a program that generates images from written instructions called a grammar. The program follows the instructions in a few seconds to create images that can contain millions of shapes.
- Improviz - a live-coding environment built for creating visual performances of abstract shapes, blurred shades and broken GIFs.
- https://github.com/kitzeller/barbara - a novel live coding interface that enables users to design languages for visual geometric pattern generation. Inspired by algorithmic quilting patterns, Barbara helps users construct languages that mimic real-world quilting procedures which can be used for both live coding performance or digital quilt recreation. Users create languages and patterns in Barbara’s online coding environment with the Parsing Expression Grammar language formalism; the resulting patterns can be freely shared, remixed, and combined into new quilts. As a push towards the applications of language-oriented design, we created Barbara to broaden access to the power of computational media and the beauty of quilting for both programmers and quilters alike. Barbara is free and open-source software.
- https://github.com/LingDong-/shan-shui-inf - Procedurally generated Chinese landscape painting.
- Picbreeder - a collaborative art application based on an idea called evolutionary art, which is a technique that allows pictures to be bred almost like animals. For example, you can evolve a butterfly into a bat by selecting parents that look like bats.
- https://github.com/junyanz/CycleGAN - Software that can generate photos from paintings, turn horses into zebras, perform style transfer, and more.
- Ganbreeder - a collaborative art tool for discovering images. Images are 'bred' by having children, mixing with other images and being shared via their URL. This is an experiment in using breeding + sharing as methods of exploring high complexity spaces. GAN's are simply the engine enabling this. Ganbreeder is very similar to, and named after, Picbreeder. It is also inspired by an earlier project of mine Facebook Graffiti which demonstrated the creative capacity of crowds.
- #000000book - An open database for Graffiti Markup Language (GML) files
- https://github.com/glmark2/glmark2 - an OpenGL 2.0 and ES 2.0 benchmark