43

I'd like to open an OpenGL context without X in Linux. Is there any way at all to do it?

I know it's possible for integrated Intel graphics card hardware, though most people have Nvidia cards in their system. I'd like to get a solution that works with Nvidia cards.

If there's no other way than through integrated Intel hardware, I guess it'd be okay to know how it's done with those.

X11 protocol itself is too large and complex. Mouse/Keyboard/Tablet input multiplexing it provides is too watered-down for modern programs. I think it's the worst roadblock that prevents Linux desktop from improving, which is why I look for alternatives.

sigjuice
  • 28,661
  • 12
  • 68
  • 93
Cheery
  • 24,645
  • 16
  • 59
  • 83
  • Why do you need to deal with X11 ? Most toolkits and libraries (like e.g. libSDL) takes care of all the low level goo for you. – nos Jul 24 '10 at 19:56
  • 2
    @nos: libSDL adopts the same limitations X11 imposes. For example: The wacom tablet gets limited into display resolution, while that tablet itself has ten times larger resolution than the display has! Large dpi mice have similar problems I've heard. – Cheery Jul 24 '10 at 20:00
  • @nos: Also, I'd really like to do a desktop environment. Not interested about writing programs. I see X11 is an excess interface that doesn't help my goals in writing a desktop environment. It gives me a large and cluttered interface in exchange to too few useful features. – Cheery Jul 24 '10 at 20:05
  • 1
    "X11 protocol ... is too large and complex." Maybe, but have you seen an insanely popular alternative to X that is supported by ATI/NVidia? My advice is to stick with whatever is available and supported, whether you like it or not. Besides, you don't have to deal with X directly. There are cross-platform libraries like SDL(games) and Qt 4 (for gui). If you don't like X, use higher level API. When X will be replaced by something else, your API will be updated, and you won't have to rewrite everything. It's like WinAPI on windows - it is still available, but you don't have to use it directly. – SigTerm Jul 24 '10 at 20:06
  • 1
    @Cheery: "Also, I'd really like to do a desktop environment." Well, good luck with that. Modern OSes and desktop environments have been in development for a long time (Xfree86 - 19 years, for example). I wouldn't start such ambitious project alone. Of course, sometimes miracles like Linux kernel (19 years of development) happen, but I wouldn't count on that. You can write something like that, but it will take lots of time. Do you want to spend years writing that thing? – SigTerm Jul 24 '10 at 20:13
  • 2
    @Cheery: Now, about your question, see this: http://superuser.com/questions/115330/on-linux-can-i-get-3d-acceleration-with-a-nvidia-card-w-o-x . If you want to try making a desktop environment, I'd recommend to make Game GUI system with SDL. Will be pretty close to the "real thing", without all the troubles. Keep in mind that even if you make an decent X alternative, it will take years until it becomes adopted. – SigTerm Jul 24 '10 at 20:14
  • 1
    @SigTerm: I've spent *years* on studying the possibilities of doing so. I've spent months to study how it'd be nice to write user interfaces. – Cheery Jul 24 '10 at 20:26
  • 1
    The problem is X11 can't stand as a low-level protocol because it is unable to represent or handle those things. Also if you attempt to make your own tablet -interface aside X11, it won't be adopted easily anyway. It's much better goal just to bypass X11 in whole. – Cheery Jul 24 '10 at 20:27
  • 1
    @Cheery: "I've spent years" If you meant to say that you spent years researching a way to write X alternative... It is your life, your decisions, so if you want to fight windmills, I'm not going to stop you. I just think that there are more interesting things in life than trying to start programming revolution.... – SigTerm Jul 24 '10 at 20:40
  • @Cherry: "if you attempt to make your own tablet -interface aside X11" if you want to make tablet interface, consider trying another platform first. It makes sense to use/support product/platform where it is easier to achieve your goal. Your time isn't exactly "free", so it makes sense to use simplest (i.e. the one that will take the least amount of your time) solution to the problem. I have nothing else to say. SigTerm out. – SigTerm Jul 24 '10 at 20:42
  • 1
    There's not an another hardware accelerated well working platform that would be open source. At least not without X11 under. This needs that "programming revolution" if good approaches cannot be found. – Cheery Jul 24 '10 at 20:44
  • @Cheery: "well working platform that would be open source" I have no problem with proprietary solutions as long as they are suitable for my goals. "This needs that "programming revolution"". As you wish. Just don't forget to post a link once you have a working version of that thing. Well, good luck with the project (and now I'm really done here). SigTerm out. – SigTerm Jul 24 '10 at 20:49
  • 2
    Qt 4 has "QWS" which is a virtual framebuffer that does not require X11 and does support OpenGL. Worth giving it a try I guess. – bparker Aug 11 '11 at 21:25
  • 1
    Everyone who seeks to drop the X environment always makes the same mistake -- loss of transparent networking. Do you really want to have to reconstruct the framebuffer and compression for remote->local graphics? – Joshua Jul 24 '10 at 20:23
  • 2
    Transparent networking is a niche most people do not ever need. If you'd really need such thing, you'd be using plan9. – Cheery Jul 24 '10 at 20:37
  • 1
    Also, Opengl doesn't work over network anyway. Whatever you're going to run over the transparent layer in X is looking ugly and certainly isn't a game or word processing software. – Cheery Jul 24 '10 at 20:38
  • 1
    In my opinion. It's much better if you just separate concerns of transparent networking and framebuffer handling. Make your own network-transparent GUI over that framebuffer if you really need one! That way you can use multiple at once. – Cheery Jul 24 '10 at 20:41
  • Cheery, OpenGL on remote workstations has already been done. It uses the graphics card on the application server and the video card on the workstation. See http://en.wikipedia.org/wiki/VirtualGL – Joshua Jul 24 '10 at 21:32

5 Answers5

43

Update (Sep. 17, 2017):

NVIDIA recently published an article detailing how to use OpenGL on headless systems, which is a very similar use case as the question describes.

In summary:

  • Link to libOpenGL.so and libEGL.so instead of libGL.so. (Your linker options should therefore be -lOpenGL -lEGL
  • Call eglGetDisplay, then eglInitialize to initialize EGL.
  • Call eglChooseConfig with the config attribute EGL_SURFACE_TYPE followed with EGL_PBUFFER_BIT.
  • Call eglCreatePbufferSurface, then eglBindApi(EGL_OPENGL_API);, then eglCreateContext and eglMakeCurrent.

From that point on, do your OpenGL rendering as usual, and you can blit your pixel buffer surface wherever you like. This supplementary article from NVIDIA includes a basic example and an example for multiple GPUs. The PBuffer surface can also be replaced with a window surface or pixmap surface, according to the application needs.

I regret not doing more research on this on my previous edit, but oh well. Better answers are better answers.

Since my answer in 2010, there have been a number of major shakeups in the Linux graphics space. So, an updated answer:

Today, nouveau and the other DRI drivers have matured to the point where OpenGL software is stable and performs reasonably well in general. With the introduction of the EGL API in Mesa, it's now possible to write OpenGL and OpenGL ES applications on even Linux desktops.

You can write your application to target EGL, and it can be run without the presence of a window manager or even a compositor. To do so, you would call eglGetDisplay, eglInitialize, and ultimately eglCreateContext and eglMakeCurrent, instead of the usual glx calls to do the same.

I do not know the specific code path for working without a display server, but EGL accepts both X11 displays and Wayland displays, and I do know it is possible for EGL to operate without one. You can create GL ES 1.1, ES 2.0, ES 3.0 (if you have Mesa 9.1 or later), and OpenGL 3.1 (Mesa 9.0 or later) contexts. Mesa has not (as of Sep. 2013) yet implemented OpenGL 3.2 Core.

Notably, on the Raspberry Pi and on Android, EGL and GL ES 2.0 (1.1 on Android < 3.0) are supported by default. On the Raspberry Pi, I don't think Wayland yet works (as of Sep. 2013), but you do get EGL without a display server using the included binary drivers. Your EGL code should also be portable (with minimal modification) to iOS, if that interests you.

Below is the outdated, previously accepted post:

I'd like to open an OpenGL context without X in linux. Is there any way at all to do it?

I believe Mesa provides a framebuffer target. If it provides any hardware acceleration at all, it will only be with hardware for which there are open source drivers that have been adapted to support such a use.

Gallium3D is also immature, and support for this isn't even on the roadmap, as far as I know.

I'd like to get a solution that works with nvidia cards.

There isn't one. Period.

NVIDIA only provides an X driver, and the Nouveau project is still immature, and doesn't support the kind of use that you're looking for, as they are currently focused only on the X11 driver.

greyfade
  • 24,948
  • 7
  • 64
  • 80
  • 1
    I don't think this is a good answer, as it is no longer true and doesn't provide a solution. Weston/wayland works with nouveau, so opengl works with NVIDIA cards without X. And comments about immaturity of striving projects tend to be aging quickly too. – elmarco Sep 26 '13 at 14:42
  • 1
    @elmarco I'll revise my answer when I have time later today. You're right; my answer is quite outdated. But to be fair, I posted it in mid-2010, when Wayland was still a prototype. – greyfade Sep 26 '13 at 15:34
8

You might be interested in a project called Wayland

http://en.wikipedia.org/wiki/Wayland_%28display_server%29

Havoc P
  • 8,365
  • 1
  • 31
  • 46
4

Have you looked at this page? http://virtuousgeek.org/blog/index.php/jbarnes/2011/10/31/writing_stanalone_programs_with_egl_and_

It is likely a bit outdated. I haven't tried yet, but I would appreciate more documentation of this type.

Probably a good idea, as of today, is to follow Wayland compositor-drm.c implementation: http://cgit.freedesktop.org/wayland/weston/tree/src/compositor-drm.c

elmarco
  • 31,633
  • 21
  • 64
  • 68
4

https://gitlab.freedesktop.org/mesa/kmscube/ is a good a reference implementation of OGL (or OGLES) hardware-accelerated rendering without an X11 or wayland dependency.

cqcallaw
  • 1,463
  • 3
  • 18
  • 29
1

You can look at how Android has solved this issues. See Android-x86 project.

Android uses mesa with egl and opengles. Android has its own simple Gralloc component for mode setting and graphic allocations. On top of that they have SurfaceFlinger component which is a composition engine, which uses OpenGLES for acceleration.

Cannot see why couldn't you use these components in similar way and even reuse the Android glue code.

user377178
  • 2,363
  • 3
  • 16
  • 11