Crossing out Integrated Circuits is due to the fact that most of the system requirements of 3D- and Render programs do not support Integrated Graphics. But if that is correct seeing the new specs and the support of the newest OpenGL and OpenCL support of Intel Iris Pro and other new issued models? The answer is at the software makers. They have to check if and with what type Intel Graphics it is possible. Communication in this respect is rather slow to say the least.

Home page OpenGL

The Industry's Foundation for High Performance Graphics
from games to virtual reality, mobile phones to supercomputers

Al jaren als Open Source beschreven en aangeduid, maar OpenGL is dat niet. OpenGL betekent dat het vrij is voor gebruik op welk platform dan ook. De broncode, zoals bij Open Source gebruikelijk, is niet beschikbaar. Wel zijn er uitgebreide Coding Resources om alle functies te beschrijven die kunnen worden toegepast door de programmeur.


No, OpenGL doesn't have any source code. GL is a specification which can be found on this website. It describes the interface the programmer uses and expected behavior. OpenGL is an open specification. Anyone can download the spec for free. This is as opposed to ISO standards and specifications, which cost money to access.

There is an implementation of GL that is Open Source and it is called Mesa3D It announces itself as implementing OpenGL 3.0 and GLSL 1.30.

OpenGL is a software interface to graphics hardware. This interface consists of about 150 distinct commands that you use to specify the objects and operations needed to produce interactive three-dimensional applications.


OpenGL is an open, cross-platform graphics standard with broad industry support. OpenGL greatly eases the task of writing real-time 2D or 3D graphics applications by providing a mature, well-documented graphics processing pipeline that supports the abstraction of current and future hardware accelerators.

In deze Wiki wordt OpenGL nog eens duidelijk uitgelegd, met alle informatie die u wenst.





Originally developed by Silicon Graphics in the early '90s, OpenGL has become the most widely-used open graphics standard in the world.. NVIDIA supports OpenGL and a complete set of OpenGL extensions, designed to give you maximum performance on our GPUs. NVIDIA continues to support OpenGL as well through technical papers and our large set of examples on our NVIDIA Graphics SDK.

Khronos Group

The Khronos Group is an open consortium of over 100 companies that have an interest in graphics and compute APIs. Along with OpenGL and OpenGL ES, it also manages OpenCL, OpenVG, EGL, WebGL, COLLADA and number of other media, sensor and vision-centric standards. There are several tiers of membership. The highest level of membership is known as a Promoter member, of which there are currently 12. They are listed here, and are AMD, (Apple in the past), ARM, Epic Games, Imagination Technologies, Intel, Nokia, NVIDIA, Qualcomm, Samsung, Sony and Vivante. Promoter members hold a seat on the board of directors at Khronos. This board has final sign off on new specifications, and determines things such as funding for working groups and the general direction of Khronos itself.

Open GL en Apple computers

Lijst met OpenGL Capabilities Tables van Apple zelf

met alle versies van OpenGL keurig gerubriceerd.

Apple en OpenGL Extensions Guide

OpenGL Extensions Guide is a reference for the extensions that OS X supports. The guide provides a short summary of each extension, a link to the official specification, availability information, and hardware renderer support.


Apple en OpenGL

On October 22, 2013, Apple released OS X Mavericks, also known as OS X version 10.9. This version of the operating system included a long awaited update to the supported version of OpenGL. The 6th edition of the OpenGL SuperBible is about OpenGL version 4.3, and unfortunately, Apple's latest and greatest only supports version 4.1 of the API. As OpenGL 4.1 was released on July 26, 2010, this puts OS X more than three years behind. However, not all of the book's samples make use of all of the latest features, and it's possible to run many of them on version 4.1 of the API. I've ported what I can.

OSX 10.9 Mac Book Pro


Porting Samples to Mac

Posted on November 11, 2013 by graham 10

What Works, What Doesn't

Now, there are clearly some samples that aren’t going to run on OpenGL 4.1. For instance, anything that uses compute shaders (the depth-of-field and flocking samples, for example), shader storage buffers (the fragmentlist sample), atomic counters or image loads and stores isn’t going to port. Luckily, although the Mac OpenGL implementation is only version 4.1, it does have a couple of extensions from OpenGL 4.2 — GL_ARB_internalformat_query and GL_ARB_texture_storage, the latter of which is used by the sb6 framework's texture loader.

To be fair, the book‚'s preface does say that the samples have been tested on Mac. We've received a couple of poor reviews on Amazon because the code isn‚Äôt usable on Mac. For my day job, I‚Äôm the architect of AMD's PC OpenGL driver, which we use for Windows and Linux. My cube neighbor is the architect for AMD‚Äôs Mac driver. Apple can be pretty secretive about what‚Äôs coming up and when, and all I had to go on when I wrote that preface (back in January of 2013) was insider knowledge of what my neighbor was working on. Even he doesn‚Äôt know what‚Äôs going to be in the next OS version or when it might release. However, it seemed that he was making pretty good progress and that I'd have a shot at building Mac versions of the samples by the time the book shipped. So much for my ability to predict the future.

The Environment

Unlike Windows and Linux, where the hardware vendor ships drivers which determine the version of OpenGL available on your machine, on the Mac platform, big chunks of the OpenGL stack are part of the operating system and so an OS update is required to bump the OpenGL version. Hence, although AMD, NVIDIA and Intel have all had OpenGL 4.x capable hardware shipping in Mac platforms for some time, we needed to wait until the 10.9 Mavericks update to actually expose it. Step 1, then, is to update the operating system to the latest available. After a quick stop off at the App Store, and a rather large, 5GiB free download (which is excellent), I was installing OS X 10.9 Mavericks on my trusty Mac Book Pro.

OS X 10.9 on Mac Book Pro

Of course, the next step is to install XCode, which includes all the developer tools. What’s more to say about XCode? It seems that people either love it or hate it. I wouldn't say I love it. I’ve used a lot of development environments in the past. While I'm most comfortable with Visual Studio, I’ve had spells with Borland's C++ Builder IDE, KDevelop, Anjuta, Eclipse, and Qt Creator. XCode is different and I would imagine would take a lot of getting used to. I was able to coerce CMake into generating XCode project files for the samples. But, once loaded into XCode, getting things to build was close to impossible. It was difficult to navigate the project, difficult to see what was going wrong, and an extremely frustrating experience.


First Pass at SuperBible 6 Samples in Xcode

In the end, I opted to generate regular Makefiles at the command prompt. This seemed much more straight forward, and after a short time, I had everything building and linking. Upon running the first example, it crashed almost immediately. Now, this may be an artifact of the version of GLFW that I’ve used for the projects, but it seems that if you ask for GLFW_ OPENGL _VERSION_MAJOR as 4 and GLFW_OPENGL_ VERSION_MINOR as 1 (i.e., ask for OpenGL 4.1), context creation will fail. However, if you set GLFW_ OPENGL_ VERSION_MAJOR to 3 and GLFW_ OPENGL_ VERSION _MINOR to 2 (ask for OpenGL 3.2), you'll get a 4.1 context. You also need to ask for a forward compatible context.

Debugging this was a pain. XCode wouldn't cooperate. I couldn't get it to debug anything it didn't build, and I couldn't get it to build my samples. Time to whip out the trusty command line debugger, gdb. Except, with Mavericks, gdb is gone and now we have lldb. lldb seems good. I'm not quite sure why a whole new debugger is necessary. I'm certain that lldb does some pretty neat things that gdb can't do, but for the things that are the same (setting breakpoints, for example), it seems to be different (and therefore unfamiliar) for the sake of it. Learning a new debugger just to step through sample applications I know already work was yet more pain.


For the most part, modifying the #version declaration in the shaders to request version 410 core rather than 430 was sufficient to get the samples working. Of course, dropping the shading language version meant that I couldn’t make use of some of the convenience functions that have been incorporated recently, such as some forms of implicit conversion and promotion from scalar to vector. I fixed the most trivial of these and was fairly quickly up and running with the first few samples.


OpenGL SuperBible Samples Running on Mac OS X 10.9

The biggest issue was the lack of explicit binding declarations on sampler uniforms in GLSL. These allow you to write, directly in the shader code, the texture unit that a sampler corresponds to. The type of declaration I'm referring to looks like this:

There's a few more conspicuously absent features in the Mavericks OpenGL implementation. As the ARB has produced new features in OpenGL, we've gone to some effort to document them not only in the core specification, but as extensions as well. This allows vendors and implementers to ship a baseline OpenGL version, but cherry-pick a couple of handy features on top of them. As I mentioned, Apple has done this with GL_ARB_internalformat_query and GL_ARB_texture_storage, but there's nothing more beyond the core features of OpenGL 4.1 and a couple of vendor extensions.

OpenGL Registry

specifications about header files, documenation and related API's including GLU, GLX and WGL. Further the use of extensions to these API's.

OpenGL wordt ondermeer door het bekende 3D-programma SketchUp Pro gebruikt om op een gemakkelijke manier 3D modellen te ontwerpen. Welke daarna indien gewenst als input kunnen worden gebruikt voor een render programma.

SketchUp Pro is een van de vele 3D tekenprogramma's die als voorwaarde stelt dat de gebruikte computer "Voor de volle 100% OpenGL compatibel moet zijn". Of te wel de gebruikte grafische kaart moet OpenGL ten volle ondersteunen. En dat lijkt makkelijker dan de praktijk uitwijst. Er zijn nl. behoorlijk wat grafische kaarten die een belangrijk deel (subset) van OpenGL ondersteunen. En dat zijn vaak de GAME kaarten. In de meeste gevallen gaat dat echter goed, een redelijk moderne grafische kaart van AMD of NVIDIA van een bepaald niveau zal zonder meer in de technische gegevens de OpenGL generatie aangeven. Of het hier om een subset gaat, wordt meestal niet vermeld.

Voor Windows

SketchUp's performance relies heavily the graphics card driver and it's ability to support OpenGL 2.0 or higher. Historically, people have seen problems with Intel-based cards with SketchUp. We don't recommend using these graphics cards with SketchUp at this time.

Voor Mac

3D class Video Card with 1GB MB of memory or higher. Please ensure that the video card driver supports OpenGL version 2.0 or higher and up to date.

Ook bij de bekende Rhino zijn er restricties voor het gebruik van Intel Graphics

Intel graphics cards

Rhino 5 SR11 runs on Intel HD3000 and newer chipsets. Common hardware that includes these newer chipsets are 13“ Apple MacBooks and Microsoft Surface Pro tablets. These are not high performance cards.

Pre-HD3000 Intel graphics chips are not recommended

Bij AutoCAD

Bij render programma Artlantis wordt de Intel Graphics niet alleen afgeraden, maar er wordt duidelijk gemaakt dat deze NIET te gebruiken is:

Uit de technische gegevens 

* Graphic chipsets are not supported.


Intel graphics en externe grafische kaart

Deze combinatie komt nog al eens voor, het is zaak om de te gebruiken software duidelijk te maken


Intel graphics

Alhoewel OpenGL wel door Intel integrated graphics wordt ondersteund, vermelden veel 3D- en render programma's bij de systeem eisen dat " Intel graphics will not be supported."

Of dat altijd helemaal terecht is valt te bezien. De nieuwste series van Intel graphics bieden meer geheugen en redelijk laatste generatie versies van OpenGL en DirectX. Let op OpenCL is lang niet altijd beschikbaar. Het nadeel is dat RAM geheugen afgepakt wordt uit de hoeveelheid geheugen. En dat is per definitie tientallen malen trager dan VRAM van de GPU.

Zie ook de speciale HD Graphics pagina op deze site.


Bij GAME programma

"Intel graphics chipsets are NOT supported"

"Intel graphics chipsets are NOT supported"


Solution for graphics issues on some Intel graphics chipsets in Fedora 22

What does not supported Integrated Graphics mean?


What is OpenGL?

OpenGL stands for Open Graphics Library. It is a specification of an API for rendering graphics, usually in 3D. OpenGL implementations are libraries that implement the API defined by the specification.

Graphics cards usually have an OpenGL implementation. Because the OpenGL specification is not platform-specific, it is possible to write an application that will be possible to use against many different types of graphics cards. It also increases the chance that the application will continue to work when new hardware will become available.

What is NOT OpenGL?

The OpenGL API only deals with rendering graphics. OpenGL does not provide functions for animations, timing, file IO, image file format processing, GUI, and so forth. OpenGL is concerned only about rendering.

GLUT is not OpenGL. It is not a part of OpenGL; it is simply a library that is used by some users to create an OpenGL window.


Who maintains the OpenGL specification?

The specification is maintained by OpenGL Architectural Review Board or ARB.

What platforms have GL?

Windows: 95 and above

Mac OSX: all versions

Linux: OpenGL is provided by open source drivers and MESA library, or by proprietary drivers.

FreeBSD: OpenGL is provided by open source drivers and MESA library or proprietary Nvidia drivers.


What 3D-file format should I use?

Newcomers often wonder what 3D file format for their mesh data to use for their project.

OpenGL does not load files; therefore, you can use any mesh format you wish. This also means that you must provide the appropriate loading code yourself; OpenGL won't help you.

There are several file format alternatives, with different capabilities. All of these formats (and more) can be loaded by the Open Asset Import library.

Wavefront .obj

This is a simple text format for mesh data. Each .obj file holds a single mesh. Obj files can reference material files, stored in the less-frequently-used .mtl format. Meshes in this format may only contain positions, normals and optionally a single texture coordinate.

Autodesk .3ds

This is a binary mesh format. This format contains materials and can store multiple named meshes in a single file.

Quake 2 .md2 and Quake 3 .md3

These are binary mesh formats. The formats do not contain material information, and they only technically store a single mesh. They do have support for keyframe animation, so a single mesh file would contain all of the animation keyframes, as well as animation data.


This is an XML-based mesh file format. It can store pretty much anything; it is primarily used for document exchange between different 3D modelling packages.

OpenGL for OS X

Who's on Board by OpenGL?

What you do not see is Microsoft !

Comparison of OpenGL and Direct3D

Direct3D application development generally targets the Microsoft Windows platform. The OpenGL API is an open standard, and implementations exist for a wide variety of platforms.

Direct3D and OpenGL are competing application programming interfaces (APIs) which can be used in applications to render 2D and 3D computer graphics. Hardware acceleration of this process has been commonplace since approximately 1999.[dubious discuss] As of 2005 [update], graphics processing units (GPUs) almost always implement a particular version of both of these APIs, such as these examples: DirectX 9 and OpenGL 2 circa 2004; DirectX 10 and OpenGL 3 circa 2008; and most recently, DirectX 11 and OpenGL 4 circa 2011. GPUs that support more recent versions of the standards are backwards-compatible with applications that utilize the older standards; for example, one can run older DirectX 9 games on a more recent DirectX 11-certified GPU.


Windows tegenhanger: DirectX


Windows 10 Insider Preview offers new opportunities to create, distribute, and monetize games. Learn about porting and publishing your game.

Choose DirectX and C++ for your Windows games

DirectX gives the highest fidelity and richest experiences in 3D gaming. DirectX supports a wide range of graphics feature levels, from DirectX 9.1 to all the latest hardware features exposed in DirectX 11 and 12. DirectX allows you to tailor your game to every PC, from power-efficient ARM-based portable tablets, to over-clocked multi-GPU gamer rigs.

Some information relates to pre-released product which may be substantially modified before it's commercially released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Direct3D 12 provides an API and platform that allows apps to take advantage of the graphics and computing capabilities of PCs equipped with one or more Direct3D 12-compatible GPUs.

What is Direct3D 12?

DirectX 12 introduces the next version of Direct3D, the 3D graphics API at the heart of DirectX. This version of Direct3D is faster and more efficient than any previous version. Direct3D 12 enables richer scenes, more objects, more complex effects, and full utilization of modern GPU hardware.


Understanding Direct3D 12

To write 3D games and apps for Windows 10 Insider Preview and Windows 10 Mobile Insider Preview, you must understand the basics of the Direct3D 12 technology, and how to prepare to use it in your games and apps.

Work Submission in Direct3D 12

To improve the CPU efficiency of Direct3D apps, Direct3D 12 no longer supports an immediate context associated with a device. Instead, apps record and then submit command lists, which contain drawing and resource management calls. These command lists can be submitted from multiple threads to one or more command queues, which manage the execution of the commands. This fundamental change increases single-threaded efficiency by allowing apps to pre-compute rendering work for later re-use, and it takes advantage of multi-core systems by spreading rendering work across multiple threads.

Why OpenGL and not DirectX?

On Windows, it's a fact that the DirectX graphics drivers are better maintained than the OpenGL graphics drivers. This is caused by the vicious cycle of vendor support. As game developers are driven from OpenGL to DirectX by other factors, the graphics card manufacturers (vendors) get less bug reports for their OpenGL drivers, extensions and documentation. This results in shakier OpenGL drivers, leading even more game developers to switch from OpenGL to DirectX. The cycle repeats.

Similarly, it's a fact that more gaming graphics programmers know how to use DirectX than OpenGL, so it's cheaper (less training required) to make a game using DirectX than OpenGL. This is the result of another vicious cycle: as more game projects use DirectX, more programmers have to learn how to use it. As more programmers learn to use it, it becomes cheaper for game projects to use DirectX than to use OpenGL.

Return of the DirectX vs. OpenGL Debates


Should I use OpenGL or DirectX?

The Industry's Foundation for High Performance Graphics

OpenGL is the most widely adopted 2D and 3D graphics API in the industry, bringing thousands of applications to a wide variety of computer platforms. It is window-system and operating-system independent as well as network-transparent. OpenGL enables developers of software for PC, workstation, and supercomputing hardware to create high-performance, visually compelling graphics software applications, in markets such as CAD, content creation, energy, entertainment, game development, manufacturing, medical, and virtual reality. OpenGL exposes all the features of the latest graphics hardware.


Any way to specify software render vs. hardware render like in DirectX?

Software Rendering

Does OpenGL contain software rendering libraries which will get automatically invoked in absence of hardware accelerator? What is the extent of functionalities which can be simulated in software this way? OR are there any third party libraries have to be used instead?

OpenGL is just the API specification. Implementations are done by hardware vendors (of course they don't provide a full software stack) or OS vendors (Mesa has some software functionality, not sure how mature that is and Apple has a full 3.2 core software renderer).

OpenGL itself specifies absolutely nothing about what is or is not hardware accelerated. Hardware vendors implement the OpenGL specification in their drivers and they decide.

Software replacement of OpenGL functionality is something that comes up fairly often, and it's a definite case of "be careful what you wish for". Your GPU plays a far greater role in this than I suspect people asking for it realise (remember: OpenGL itself does not actually draw anything - all it does is tell your driver to pass commands on to your GPU, which is where all the work really happens). OpenGL is not software and it is not a software library, and software replacement of rendering functionality may run as slow as less than 1 frame per second.

MathWorks Matlab

is een van de programma's die OpenGL gebruiken om de uitkomsten van wiskundige formules op een goede manier op het scherm te visualiseren.

A first order ray tracing can be more efficient and easily paralyzes over multiple cores. Maybe you can look into something like PovRay.


Hardware acceleration

Why would you use software rendering over hardware rendering, today?

Mesa 3D is an Open-source implementatie van OpenGL specificaties.

OpenGL software rendering alternatives

Software vs OpenGL Quake - which is better?

Me and OpenGL

I used to be pretty passionate about the OpenGL graphics API, and I spent a fair amount of my time working to make it successful on the PC for games. I still use it regularly and think it's a pretty well designed API, and it's certainly still much more pleasant to program with than Direct3D, even after all of these years and versions, but the heat has gone out of the issue for me. Direct3D won the war. SGI is basically dead, the OpenGL Architecture Review Board is mostly reactive instead of proactive, and Direct3D is the stable and mature platform that drives the features for each generation.

How to learn OpenGL?

A good way to learn OpenGL is to use it

Gebruikte wiskundige formules en definities in OpenGL

Math Cheatsheet
* Trigonometry
* Pi
* Cosinus & Sinus
* Unit circle
* Vectors
* Homogeneous coordinates
* Length
* Cross product
* Dot product
* Addition and substraction
* Multiplication
* Normalization
* Matrices
* Matrix-Matrix multiplication
* Matrix-Vector multiplication
* Usual Transformations


OpenGL Mathematics

OpenGL Mathematics (GLM) is a header only C++ mathematics library for graphics software based on the OpenGL Shading Language (GLSL) specifications.

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.

* GLM is written in C++98 but can take advantage of C++11 when supported by the compiler. It is a platform independent library with no dependence and it officially supports the following compilers:

* Apple Clang 4.0 and higher
* GCC 4.2 and higher
* Intel C++ Composer XE 2013 and higher
* LLVM 3.0 and higher
* Visual C++ 2010 and higher
* CUDA 4.0 and higher (experimental)
* Any conform C++98 or C++11 compiler

GLM manual


OpenGL SuperBible

About the OpenGL SuperBible

OpenGL SuperBible, Sixth Edition, is the definitive programmer's guide, tutorial, and reference for the world’s leading 3D API for real-time computer graphics, OpenGL 4.3. The best all-around introduction to OpenGL for developers at all levels of experience, it clearly explains both the newest API and indispensable related concepts. You’ll find up-to-date, hands-on guidance for all facets of modern OpenGL development on both desktop and mobile platforms, including transformations, texture mapping, shaders, buffers, geometry management, and much more.

Extensively revised, this edition presents many new OpenGL 4.3 features, including compute shaders, texture views, indirect draws, and enhanced API debugging. It has been reorganized to focus more tightly on the API, to cover the entire pipeline earlier, and to help you thoroughly understand the interactions between OpenGL and graphics hardware.

Coverage includes

* A practical introduction to the essentials of realtime 3D graphics

* Core OpenGL 4.3 techniques for rendering, transformations, and texturing

* Foundational math for creating interesting 3D graphics with OpenGL

* Writing your own shaders, with examples to get you started

* Cross-platform OpenGL, including essential platform-specific API initialization material for Linux, OS X, and Windows

* Vertex processing, drawing commands, primitive processing, fragments, and framebuffers

* Using compute shaders to harness today’s graphics cards for more than graphics

* Monitoring and controlling the OpenGL graphics pipeline

* Advanced rendering: light simulation, artistic and non-photo-realistic rendering, and deferred shading

* Modern OpenGL debugging and performance optimization


screenshots bij OpenGL superbible uitgave



OpenGL SuperBible Depth-of-Field Example

OpenGL SuperBible Ambient Occlusion Example


OpenGL tools and links

OpenGL Mathematics (GLM) is a C++ mathematics library for graphics C++ programs based on the OpenGL Shading Language (GLSL) specifications.

This liberary works perfectly with OpenGL but it also ensures interoperability with other third party libraries and SDK. It's a good candidate for Software Renderring (Raytracing / rasterisation), image processing, physic simulations and others.

OpenGL Mathematics website