Managed to run webots in virtual machine

[Kreijstal]

you just need the following dlls

• Place next to webots.exe:
  • opengl32.dll
  • libgallium_wgl.dll
  • libspirv_to_dxil.dll
  • clon12compiler.dll
  • dxil.dll

and the following env vars

• MESA_LOADER_DRIVER_OVERRIDE=d3d12
• MESA_GL_VERSION_OVERRIDE=3.3
• MESA_GLSL_VERSION_OVERRIDE=330

before it crashed or didnt work.. maybe it helps someone

[Kreijstal]

in case you do not want to use dxil.dll it is still possible you only need opengl32.dll from for example msys2 project, then do.

MESA_GLSL_VERSION_OVERRIDE=330 MESA_GL_VERSION_OVERRIDE=3.3 MESA_LOADER_DRIVER_OVERRIDE=llvmpipe LIBGL_ALWAYS_SOFTWARE=1 ./webots.exe

By the way it is possible to detect this behaviour so instead of crashing on VM theoretically the program can detect this and fallback to software rendering... webots should do this.

[Kreijstal]

here is a poc

#include <windows.h>
#include <QApplication>
#include <QMainWindow>
#include <QOpenGLWidget>
#include <QOpenGLFunctions>
#include <iostream>
#include <QTimer>
#include <vector>

// Helper to get module name
std::string GetModuleName(HMODULE hMod) {
    char path[MAX_PATH];
    if (GetModuleFileNameA(hMod, path, MAX_PATH)) {
        const char* name = strrchr(path, '\\');
        return name ? name + 1 : path;
    }
    return "Unknown";
}

// Hook function for ExitProcess
void WINAPI HookedExitProcess(UINT uExitCode) {
    std::cerr << "HookedExitProcess called with code " << uExitCode << std::endl;
    
    // Check for 87 (ERROR_INVALID_PARAMETER) or 0x80070057 (E_INVALIDARG / HRESULT_FROM_WIN32(87))
    if (uExitCode == 87 || uExitCode == 0x80070057) {
        std::cerr << "Intercepted ExitProcess(" << uExitCode << ") - Driver crash detected!" << std::endl;
        
        // Check if we are already in software mode to avoid infinite loop
        if (!getenv("LIBGL_ALWAYS_SOFTWARE")) {
            std::cerr << "Restarting with software rendering..." << std::endl;
            
            _putenv("LIBGL_ALWAYS_SOFTWARE=1");
            
            wchar_t exePath[MAX_PATH];
            GetModuleFileNameW(NULL, exePath, MAX_PATH);
            
            STARTUPINFOW si = { sizeof(si) };
            PROCESS_INFORMATION pi;
            
            // Re-launch ourselves
            if (CreateProcessW(NULL, GetCommandLineW(), 
                              NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
                CloseHandle(pi.hProcess);
                CloseHandle(pi.hThread);
                // Terminate cleanly
                TerminateProcess(GetCurrentProcess(), 0);
                return;
            }
        }
    }
    
    // Fallback: Terminate process since we can't call original ExitProcess
    // (we overwrote its prologue and don't have a trampoline)
    TerminateProcess(GetCurrentProcess(), uExitCode);
}

// Inline Hooking
void InstallInlineHook() {
    void* pExitProcess = (void*)GetProcAddress(GetModuleHandleA("KERNEL32.dll"), "ExitProcess");
    if (!pExitProcess) return;
    
    DWORD dwOldProtect;
    VirtualProtect(pExitProcess, 12, PAGE_EXECUTE_READWRITE, &dwOldProtect);
    
    // MOV RAX, HookedExitProcess
    // JMP RAX
    // 48 B8 <64-bit address>
    // FF E0
    unsigned char patch[12] = { 0x48, 0xB8 };
    *(void**)(patch + 2) = (void*)HookedExitProcess;
    patch[10] = 0xFF;
    patch[11] = 0xE0;
    
    memcpy(pExitProcess, patch, 12);
    
    VirtualProtect(pExitProcess, 12, dwOldProtect, &dwOldProtect);
    std::cout << "Inline hooked ExitProcess at " << pExitProcess << std::endl;
}

class TestWidget : public QOpenGLWidget, protected QOpenGLFunctions {
public:
    TestWidget(QWidget *parent = nullptr) : QOpenGLWidget(parent) {}

protected:
    void initializeGL() override {
        initializeOpenGLFunctions();
        
        const GLubyte *renderer = glGetString(GL_RENDERER);
        const GLubyte *version = glGetString(GL_VERSION);
        
        std::cout << "Renderer: " << (renderer ? (const char*)renderer : "NULL") << std::endl;
        std::cout << "Version: " << (version ? (const char*)version : "NULL") << std::endl;
        
        testTextures();
        QTimer::singleShot(1000, qApp, [](){
            std::cout << "Timer triggered - quitting application." << std::endl;
            QApplication::quit();
        });
    }

    void testTextures() {
        std::cout << "Testing textures..." << std::endl;
        GLuint tex1;
        glGenTextures(1, &tex1);
        glBindTexture(GL_TEXTURE_2D, tex1);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, 256, 256, 0, GL_RGB, GL_HALF_FLOAT, NULL);
        std::cout << (glGetError() == GL_NO_ERROR ? "OK" : "Error") << std::endl;
    }
};

int runApp(int argc, char **argv) {
    QCoreApplication::setAttribute(Qt::AA_UseDesktopOpenGL);
    QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
    
    QApplication app(argc, argv);

    QSurfaceFormat format;
    format.setMajorVersion(3);
    format.setMinorVersion(3);
    format.setProfile(QSurfaceFormat::CompatibilityProfile);
    QSurfaceFormat::setDefaultFormat(format);

    QMainWindow window;
    TestWidget *widget = new TestWidget(&window);
    window.setCentralWidget(widget);
    window.resize(800, 600);
    window.show();
    
    app.processEvents();
    
    if (!widget->context() || !widget->context()->isValid()) {
        std::cerr << "Context creation failed!" << std::endl;
        return 1;
    }
    
    return app.exec();
}

int main(int argc, char **argv) {
    // Install inline hook immediately
    InstallInlineHook();

    // Force load local opengl32.dll
    HMODULE hGL = LoadLibraryA("opengl32.dll");
    if (hGL) std::cout << "Loaded local opengl32.dll" << std::endl;
    
    std::cout << "=== " << (getenv("LIBGL_ALWAYS_SOFTWARE") ? "Software" : "Default") << " rendering ===" << std::endl;
    
    return runApp(argc, argv);
}

this should fallback to software rendering automagically.

[Kreijstal]

I guess mesa needs to be patched ... to find out