Load Textures while rendering (Multithreaded)?

You need to create an OpenGL context for each thread that you need to call OpenGL methods from. This is how OpenGL works, there's no way around this limitation. The documentation has more information on multiple contexts.

However, you can still load resources asynchronously using a single context. The trick is to separate the "disk -> system memory" part (slow) from the "system memory -> OpenGL" part (fast) and distribute the slow part to a thread pool. Whenever a background thread finishes loading, you can signal the main thread to generate a new texture object and upload the data to OpenGL.

The reason why this works is because the bottleneck lies in disk access. Reading the texture from disk may take several ms, whereas uploading to OpenGL requires just a few μs, thus it doesn't really hurt to leave the second part to the main thread. Much simpler than creating multiple contexts, too (one for each loader thread).

Note that you'll likely get an even larger performance improvement if you use dds-compressed textures. The reason is that you can send them directly from disk to OpenGL (no need to decode into system memory first, as is the case with jpg or png. Parse the header, find out the format and upload the compressed data directly).

New windows remain invisible until you call INativeWindow.Visible = true or call the IGameWindow.Run() method.

using OpenTK;
using OpenTK.Graphics;
 
// Temporarily disable current context, otherwise resource sharing may fail.
EventWaitHandle context_ready = new EventWaitHandle(false, EventResetMode.AutoReset);
Context.MakeCurrent(null);
var thread = new Thread(() =>
{
    INativeWindow window = new NativeWindow();
    IGraphicsContext context = new GraphicsContext(GraphicsMode.Default, window.WindowInfo);
    context.MakeCurrent(window.WindowInfo); // Edit: this is necessary for GL functions to work
 
    context_ready.Set();
    while (window.Exists)
    {
         window.ProcessEvents();
 
         // Perform your processing here
 
         Thread.Sleep(1); // Limit CPU usage, if necessary
    }
});
thread.IsBackground = true;
thread.Start();
 
context_ready.WaitOne();
MakeCurrent();

That's all there is to it, actually. The new context will automatically be shared if possible (for best results try using the same GraphicsMode and the same context flags and version).

Try adding context.MakeCurrent(window.WindowInfo) in the new thread. Also make sure that both contexts are using the same driver (GL.GetString(StringName.Renderer/Vender)), otherwise access violations may occur. (This is uncommon but the new context might be falling back to Microsoft's software renderer for some reason.)

Alright, added the missing MakeCurrent call to the documentation.

I can reproduce the sharing failure here (Nvidia card) and have added some debugging code to the 1.0 branch to print an error code when sharing fails (debug mode, only). My error code is 170 (resource busy), which might indicate that the main context should not be in use before creating the background context. Investigating.

Edit: indeed, if you make the main context non-current, wglShareLists succeeds. This is not mentioned in the relevant documentation, great. Fixed the code above (and in the documentation) to reflect this discovery.

It may be good to point out you need a GL.Flush() after the "// Perform your processing here". My last few textures were showing up black because OpenGL was not recognizing them until theFLush.