node-gpuinfo 1.0.0

package/build/gpu.vcxproj.filters

@@ -0,0 +1,169 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="..">
+      <UniqueIdentifier>{739DB09A-CC57-A953-A6CF-F64FA08E4FA7}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src">
+      <UniqueIdentifier>{8CDEE807-BC53-E450-C8B8-4DEBB66742D4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..">
+      <UniqueIdentifier>{739DB09A-CC57-A953-A6CF-F64FA08E4FA7}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src">
+      <UniqueIdentifier>{8CDEE807-BC53-E450-C8B8-4DEBB66742D4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..">
+      <UniqueIdentifier>{739DB09A-CC57-A953-A6CF-F64FA08E4FA7}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src">
+      <UniqueIdentifier>{8CDEE807-BC53-E450-C8B8-4DEBB66742D4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src\vendor">
+      <UniqueIdentifier>{DB63429E-9D27-F281-39C4-285ED58EA02F}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..">
+      <UniqueIdentifier>{739DB09A-CC57-A953-A6CF-F64FA08E4FA7}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src">
+      <UniqueIdentifier>{8CDEE807-BC53-E450-C8B8-4DEBB66742D4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src\vendor">
+      <UniqueIdentifier>{DB63429E-9D27-F281-39C4-285ED58EA02F}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..">
+      <UniqueIdentifier>{739DB09A-CC57-A953-A6CF-F64FA08E4FA7}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src">
+      <UniqueIdentifier>{8CDEE807-BC53-E450-C8B8-4DEBB66742D4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src\vendor">
+      <UniqueIdentifier>{DB63429E-9D27-F281-39C4-285ED58EA02F}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..">
+      <UniqueIdentifier>{739DB09A-CC57-A953-A6CF-F64FA08E4FA7}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src">
+      <UniqueIdentifier>{8CDEE807-BC53-E450-C8B8-4DEBB66742D4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src\windows">
+      <UniqueIdentifier>{C1450D01-C033-76F3-3763-6DE88AF48A77}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..">
+      <UniqueIdentifier>{739DB09A-CC57-A953-A6CF-F64FA08E4FA7}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src">
+      <UniqueIdentifier>{8CDEE807-BC53-E450-C8B8-4DEBB66742D4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src\windows">
+      <UniqueIdentifier>{C1450D01-C033-76F3-3763-6DE88AF48A77}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..">
+      <UniqueIdentifier>{739DB09A-CC57-A953-A6CF-F64FA08E4FA7}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src">
+      <UniqueIdentifier>{8CDEE807-BC53-E450-C8B8-4DEBB66742D4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src\windows">
+      <UniqueIdentifier>{C1450D01-C033-76F3-3763-6DE88AF48A77}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..">
+      <UniqueIdentifier>{739DB09A-CC57-A953-A6CF-F64FA08E4FA7}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src">
+      <UniqueIdentifier>{8CDEE807-BC53-E450-C8B8-4DEBB66742D4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src\includes">
+      <UniqueIdentifier>{7D4666A0-7903-1110-FE31-54663A46932E}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src\includes\adlx">
+      <UniqueIdentifier>{00A4720B-62F7-E6BC-4A80-2DC4C97AFB43}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src\includes\adlx\ADLXHelper">
+      <UniqueIdentifier>{230812EB-C8DA-5D04-0516-B8E67106717E}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..">
+      <UniqueIdentifier>{739DB09A-CC57-A953-A6CF-F64FA08E4FA7}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src">
+      <UniqueIdentifier>{8CDEE807-BC53-E450-C8B8-4DEBB66742D4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src\includes">
+      <UniqueIdentifier>{7D4666A0-7903-1110-FE31-54663A46932E}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src\includes\adlx">
+      <UniqueIdentifier>{00A4720B-62F7-E6BC-4A80-2DC4C97AFB43}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..\src\includes\adlx\ADLXHelper">
+      <UniqueIdentifier>{230812EB-C8DA-5D04-0516-B8E67106717E}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="C:">
+      <UniqueIdentifier>{7B735499-E5DD-1C2B-6C26-70023832A1CF}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="C:\Users">
+      <UniqueIdentifier>{E9F714C1-DA89-54E2-60CF-39FEB20BF756}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="C:\Users\oxmc">
+      <UniqueIdentifier>{16C4EF74-13EA-84F4-1FCD-E855EF9CF51A}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="C:\Users\oxmc\Documents">
+      <UniqueIdentifier>{87566BA0-CA33-1144-65F5-087C5F9D6C20}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="C:\Users\oxmc\Documents\Github">
+      <UniqueIdentifier>{61AF0388-6A36-F721-D5C4-52DAD1BC98B5}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="C:\Users\oxmc\Documents\Github\nodeGPU">
+      <UniqueIdentifier>{46CE6DFF-F029-A042-EDBA-2C316EC513C6}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="C:\Users\oxmc\Documents\Github\nodeGPU\node_modules">
+      <UniqueIdentifier>{56DF7A98-063D-FB9D-485C-089023B4C16A}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="C:\Users\oxmc\Documents\Github\nodeGPU\node_modules\node-gyp">
+      <UniqueIdentifier>{77348C0E-2034-7791-74D5-63C077DF5A3B}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="C:\Users\oxmc\Documents\Github\nodeGPU\node_modules\node-gyp\src">
+      <UniqueIdentifier>{8CDEE807-BC53-E450-C8B8-4DEBB66742D4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="..">
+      <UniqueIdentifier>{739DB09A-CC57-A953-A6CF-F64FA08E4FA7}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\src\binding.cpp">
+      <Filter>..\src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\gpu_info.c">
+      <Filter>..\src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\vendor\nvidia.c">
+      <Filter>..\src\vendor</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\vendor\amd.c">
+      <Filter>..\src\vendor</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\vendor\intel.c">
+      <Filter>..\src\vendor</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\windows\nvidia_windows.c">
+      <Filter>..\src\windows</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\windows\amd_windows.c">
+      <Filter>..\src\windows</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\windows\intel_windows.c">
+      <Filter>..\src\windows</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\includes\adlx\ADLXHelper\ADLXHelper.c">
+      <Filter>..\src\includes\adlx\ADLXHelper</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\includes\adlx\ADLXHelper\WinAPIS.c">
+      <Filter>..\src\includes\adlx\ADLXHelper</Filter>
+    </ClCompile>
+    <ClCompile Include="C:\Users\oxmc\Documents\Github\nodeGPU\node_modules\node-gyp\src\win_delay_load_hook.cc">
+      <Filter>C:\Users\oxmc\Documents\Github\nodeGPU\node_modules\node-gyp\src</Filter>
+    </ClCompile>
+    <None Include="..\binding.gyp">
+      <Filter>..</Filter>
+    </None>
+  </ItemGroup>
+</Project>

package/example.js

@@ -0,0 +1,69 @@
+/**
+ * Example usage of node-gpu
+ * 
+ * This demonstrates how to retrieve GPU information from the system.
+ * Run with: node example.js
+ */
+
+const gpu = require('./index');
+
+console.log('=== node-gpu Example ===\n');
+
+try {
+    // Get GPU count
+    console.log('--- GPU Count ---');
+    const gpuCount = gpu.getGpuCount();
+    console.log('Number of GPUs:', gpuCount);
+    console.log();
+
+    if (gpuCount === 0) {
+        console.log('No GPUs detected in the system.');
+        process.exit(0);
+    }
+
+    // Get information for each GPU
+    for (let i = 0; i < gpuCount; i++) {
+        console.log(`--- GPU ${i} Information ---`);
+        const gpuInfo = gpu.getGpuInfo(i);
+        
+        console.log('Index:', gpuInfo.index);
+        console.log('Vendor:', gpuInfo.vendor);
+        console.log('Name:', gpuInfo.name || 'N/A');
+        console.log('UUID:', gpuInfo.uuid || 'N/A');
+        console.log('PCI Bus ID:', gpuInfo.pciBusId || 'N/A');
+        console.log();
+        
+        console.log('Memory:');
+        console.log('  Total:', gpuInfo.memoryTotal ? `${gpuInfo.memoryTotal} MB` : 'N/A');
+        console.log('  Used:', gpuInfo.memoryUsed ? `${gpuInfo.memoryUsed} MB` : 'N/A');
+        console.log('  Free:', gpuInfo.memoryFree ? `${gpuInfo.memoryFree} MB` : 'N/A');
+        console.log();
+        
+        console.log('Utilization:');
+        console.log('  GPU:', gpuInfo.gpuUtilization !== undefined ? `${gpuInfo.gpuUtilization.toFixed(1)}%` : 'N/A');
+        console.log('  Memory:', gpuInfo.memoryUtilization !== undefined ? `${gpuInfo.memoryUtilization.toFixed(1)}%` : 'N/A');
+        console.log();
+        
+        console.log('Temperature:', gpuInfo.temperature !== undefined ? `${gpuInfo.temperature.toFixed(1)}°C` : 'N/A');
+        console.log('Power Usage:', gpuInfo.powerUsage !== undefined ? `${gpuInfo.powerUsage.toFixed(1)} W` : 'N/A');
+        console.log();
+        
+        console.log('Clocks:');
+        console.log('  Core Clock:', gpuInfo.coreClock ? `${gpuInfo.coreClock} MHz` : 'N/A');
+        console.log('  Memory Clock:', gpuInfo.memoryClock ? `${gpuInfo.memoryClock} MHz` : 'N/A');
+        console.log();
+        
+        console.log('Fan Speed:', gpuInfo.fanSpeed !== undefined ? `${gpuInfo.fanSpeed.toFixed(1)}%` : 'N/A');
+        console.log();
+    }
+
+    // Get all GPU information at once
+    console.log('--- All GPU Information (Single Call) ---');
+    const allGpuInfo = gpu.getAllGpuInfo();
+    console.log(JSON.stringify(allGpuInfo, null, 2));
+
+} catch (error) {
+    console.error('Error:', error.message);
+    console.error('\nNote: Some information may require elevated privileges (administrator/root) or specific GPU drivers.');
+    process.exit(1);
+}

package/index.js

@@ -0,0 +1,33 @@
+/**
+ * node-gpu - Cross-platform GPU information reader
+ * 
+ * This module provides a simple interface to read GPU information
+ * from the system using native C++ code.
+ */
+
+try {
+    // Try to load prebuilt binary via node-pre-gyp
+    const binding_path = require('@mapbox/node-pre-gyp').find(
+        require('path').resolve(__dirname, './package.json')
+    );
+    module.exports = require(binding_path);
+} catch (err) {
+    try {
+        // Fall back to Release build
+        module.exports = require('./build/Release/gpu.node');
+    } catch (err2) {
+        try {
+            // Fall back to Debug build
+            module.exports = require('./build/Debug/gpu.node');
+        } catch (err3) {
+            // If no build is available, throw a helpful error
+            throw new Error(
+                'Native addon not found. Please run "npm install" or "npm run build" to compile the native addon.\n' +
+                'Original error: ' + err.message
+            );
+        }
+    }
+}
+
+// Add version information
+module.exports.version = require('./package.json').version;

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "node-gpuinfo",
+  "version": "1.0.0",
+  "description": "A cross-platform Node.js native addon for retrieving detailed GPU information.",
+  "main": "index.js",
+  "scripts": {
+    "install": "node-pre-gyp install --fallback-to-build",
+    "build": "node-gyp rebuild",
+    "clean": "node-gyp clean",
+    "test": "node example.js",
+    "package": "node-pre-gyp package",
+    "publish-binary": "node-pre-gyp-github publish",
+    "prepublishOnly": "npm run build"
+  },
+  "binary": {
+    "module_name": "gpu",
+    "module_path": "./build/Release/",
+    "package_name": "{module_name}-v{version}-{node_abi}-{platform}-{arch}.tar.gz",
+    "host": "https://github.com/oxmc/node-gpu/releases/download/",
+    "remote_path": "v{version}"
+  },
+  "keywords": [
+    "gpu",
+    "nvidia",
+    "amd",
+    "intel",
+    "graphics",
+    "hardware",
+    "monitoring",
+    "performance",
+    "temperature",
+    "memory",
+    "utilization",
+    "native",
+    "addon",
+    "cross-platform",
+    "windows",
+    "linux",
+    "macos"
+  ],
+  "author": "Seth Olivarez <me@oxmc.me> (https://oxmc.me)",
+  "license": "GPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oxmc/node-gpu.git"
+  },
+  "bugs": {
+    "url": "https://github.com/oxmc/node-gpu/issues"
+  },
+  "homepage": "https://github.com/oxmc/node-gpu#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "gypfile": true,
+  "dependencies": {
+    "@mapbox/node-pre-gyp": "^2.0.3",
+    "node-addon-api": "^8.0.0"
+  },
+  "devDependencies": {
+    "node-gyp": "^10.0.0",
+    "node-pre-gyp-github": "^2.0.0"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ]
+}

package/src/binding.cpp

@@ -0,0 +1,201 @@
+#include <napi.h>
+extern "C" {
+#include "gpu_info.h"
+}
+#include <string>
+
+namespace gpu {
+
+/**
+ * Convert gpu_info_t struct to JavaScript object
+ */
+Napi::Object GpuInfoToObject(Napi::Env env, const gpu_info_t& info) {
+    Napi::Object obj = Napi::Object::New(env);
+    
+    obj.Set("index", Napi::Number::New(env, info.index));
+    
+    // Vendor
+    std::string vendor_str;
+    switch (info.vendor) {
+        case GPU_VENDOR_NVIDIA: vendor_str = "NVIDIA"; break;
+        case GPU_VENDOR_AMD: vendor_str = "AMD"; break;
+        case GPU_VENDOR_INTEL: vendor_str = "Intel"; break;
+        default: vendor_str = "Unknown"; break;
+    }
+    obj.Set("vendor", Napi::String::New(env, vendor_str));
+    
+    obj.Set("name", Napi::String::New(env, info.name));
+    obj.Set("uuid", Napi::String::New(env, info.uuid));
+    obj.Set("pciBusId", Napi::String::New(env, info.pci_bus_id));
+    
+    // Memory (in MB)
+    obj.Set("memoryTotal", Napi::Number::New(env, info.memory_total));
+    obj.Set("memoryUsed", Napi::Number::New(env, info.memory_used));
+    obj.Set("memoryFree", Napi::Number::New(env, info.memory_free));
+    
+    // Utilization (percentage)
+    obj.Set("gpuUtilization", Napi::Number::New(env, info.gpu_utilization));
+    obj.Set("memoryUtilization", Napi::Number::New(env, info.memory_utilization));
+    
+    // Temperature (Celsius)
+    obj.Set("temperature", Napi::Number::New(env, info.temperature));
+    
+    // Power (Watts)
+    obj.Set("powerUsage", Napi::Number::New(env, info.power_usage));
+    
+    // Clocks (MHz)
+    obj.Set("coreClock", Napi::Number::New(env, info.core_clock));
+    obj.Set("memoryClock", Napi::Number::New(env, info.memory_clock));
+    
+    // Fan speed (percentage)
+    obj.Set("fanSpeed", Napi::Number::New(env, info.fan_speed));
+    
+    return obj;
+}
+
+/**
+ * Node.js binding: initialize()
+ * Initialize the GPU information library
+ */
+Napi::Value Initialize(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    gpu_error_t result = gpu_info_init();
+    
+    if (result != GPU_SUCCESS) {
+        Napi::Error::New(env, "Failed to initialize GPU library")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    
+    return Napi::Boolean::New(env, true);
+}
+
+/**
+ * Node.js binding: cleanup()
+ * Cleanup the GPU information library
+ */
+Napi::Value Cleanup(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    gpu_error_t result = gpu_info_cleanup();
+    
+    if (result != GPU_SUCCESS) {
+        Napi::Error::New(env, "Failed to cleanup GPU library")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    
+    return Napi::Boolean::New(env, true);
+}
+
+/**
+ * Node.js binding: getGpuCount()
+ * Get the number of GPUs in the system
+ */
+Napi::Value GetGpuCount(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    int32_t count = 0;
+    gpu_error_t result = gpu_get_count(&count);
+    
+    if (result != GPU_SUCCESS) {
+        if (result == GPU_ERROR_NO_GPU) {
+            return Napi::Number::New(env, 0);
+        }
+        Napi::Error::New(env, "Failed to get GPU count")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    
+    return Napi::Number::New(env, count);
+}
+
+/**
+ * Node.js binding: getGpuInfo(index)
+ * Get information about a specific GPU by index
+ */
+Napi::Value GetGpuInfo(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    // Check arguments
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Expected GPU index as number")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    
+    int32_t index = info[0].As<Napi::Number>().Int32Value();
+    
+    gpu_info_t gpu_info;
+    gpu_error_t result = gpu_get_info(index, &gpu_info);
+    
+    if (result != GPU_SUCCESS) {
+        std::string error_msg = "Failed to get GPU info for index " + std::to_string(index);
+        Napi::Error::New(env, error_msg)
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    
+    return GpuInfoToObject(env, gpu_info);
+}
+
+/**
+ * Node.js binding: getAllGpuInfo()
+ * Get information about all GPUs in the system
+ */
+Napi::Value GetAllGpuInfo(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    // Get GPU count
+    int32_t count = 0;
+    gpu_error_t result = gpu_get_count(&count);
+    
+    if (result != GPU_SUCCESS || count == 0) {
+        return Napi::Array::New(env, 0);
+    }
+    
+    // Create array to hold all GPU info
+    Napi::Array gpuArray = Napi::Array::New(env, count);
+    
+    // Get info for each GPU
+    for (int32_t i = 0; i < count; i++) {
+        gpu_info_t gpu_info;
+        result = gpu_get_info(i, &gpu_info);
+        
+        if (result == GPU_SUCCESS) {
+            gpuArray[i] = GpuInfoToObject(env, gpu_info);
+        } else {
+            // Add null for failed GPUs
+            gpuArray[i] = env.Null();
+        }
+    }
+    
+    return gpuArray;
+}
+
+/**
+ * Initialize the Node.js addon
+ */
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    // Auto-initialize on module load
+    gpu_info_init();
+    
+    // Export functions
+    exports.Set("initialize", Napi::Function::New(env, Initialize));
+    exports.Set("cleanup", Napi::Function::New(env, Cleanup));
+    exports.Set("getGpuCount", Napi::Function::New(env, GetGpuCount));
+    exports.Set("getGpuInfo", Napi::Function::New(env, GetGpuInfo));
+    exports.Set("getAllGpuInfo", Napi::Function::New(env, GetAllGpuInfo));
+    
+    return exports;
+}
+
+} // namespace gpu
+
+// Register the addon (must be outside namespace)
+Napi::Object InitModule(Napi::Env env, Napi::Object exports) {
+    return gpu::Init(env, exports);
+}
+
+NODE_API_MODULE(gpu, InitModule)

package/src/gpu_info.c

@@ -0,0 +1,130 @@
+#include "gpu_info.h"
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+// Forward declarations for vendor functions
+gpu_error_t nvidia_get_gpu_count(int32_t* count);
+gpu_error_t nvidia_get_gpu_info(int32_t index, gpu_info_t* info);
+gpu_error_t amd_get_gpu_count(int32_t* count);
+gpu_error_t amd_get_gpu_info(int32_t index, gpu_info_t* info);
+gpu_error_t intel_get_gpu_count(int32_t* count);
+gpu_error_t intel_get_gpu_info(int32_t index, gpu_info_t* info);
+
+static bool g_initialized = false;
+
+gpu_error_t gpu_info_init(void) {
+    if (g_initialized) {
+        return GPU_SUCCESS;
+    }
+    
+    // Platform-specific initialization
+#ifdef _WIN32
+    // Windows-specific init
+#else
+    // Linux-specific init
+#endif
+    
+    g_initialized = true;
+    return GPU_SUCCESS;
+}
+
+gpu_error_t gpu_info_cleanup(void) {
+    if (!g_initialized) {
+        return GPU_SUCCESS;
+    }
+    
+    // Platform-specific cleanup
+    
+    g_initialized = false;
+    return GPU_SUCCESS;
+}
+
+gpu_error_t gpu_get_count(int32_t* count) {
+    if (!g_initialized) {
+        return GPU_ERROR_API_FAILED;
+    }
+    
+    if (!count) {
+        return GPU_ERROR_INVALID_PARAM;
+    }
+    
+    int32_t total_count = 0;
+    int32_t nvidia_count = 0;
+    int32_t amd_count = 0;
+    int32_t intel_count = 0;
+    
+    // Get counts from all vendors
+    if (nvidia_get_gpu_count(&nvidia_count) == GPU_SUCCESS) {
+        total_count += nvidia_count;
+    }
+    
+    if (amd_get_gpu_count(&amd_count) == GPU_SUCCESS) {
+        total_count += amd_count;
+    }
+    
+    if (intel_get_gpu_count(&intel_count) == GPU_SUCCESS) {
+        total_count += intel_count;
+    }
+    
+    *count = total_count;
+    return total_count > 0 ? GPU_SUCCESS : GPU_ERROR_NO_GPU;
+}
+
+gpu_error_t gpu_get_info(int32_t index, gpu_info_t* info) {
+    if (!g_initialized || !info) {
+        return GPU_ERROR_INVALID_PARAM;
+    }
+    
+    int32_t nvidia_count = 0;
+    int32_t amd_count = 0;
+    int32_t intel_count = 0;
+    
+    // Get vendor counts
+    nvidia_get_gpu_count(&nvidia_count);
+    amd_get_gpu_count(&amd_count);
+    intel_get_gpu_count(&intel_count);
+    
+    if (index < nvidia_count) {
+        // NVIDIA GPU
+        return nvidia_get_gpu_info(index, info);
+    } else if (index < nvidia_count + amd_count) {
+        // AMD GPU
+        int32_t amd_index = index - nvidia_count;
+        return amd_get_gpu_info(amd_index, info);
+    } else if (index < nvidia_count + amd_count + intel_count) {
+        // Intel GPU
+        int32_t intel_index = index - nvidia_count - amd_count;
+        return intel_get_gpu_info(intel_index, info);
+    }
+    
+    return GPU_ERROR_INVALID_PARAM;
+}
+
+const char* gpu_error_string(gpu_error_t error) {
+    switch (error) {
+        case GPU_SUCCESS: return "Success";
+        case GPU_ERROR_NOT_SUPPORTED: return "Operation not supported";
+        case GPU_ERROR_NO_GPU: return "No GPU found";
+        case GPU_ERROR_ACCESS_DENIED: return "Access denied";
+        case GPU_ERROR_INVALID_PARAM: return "Invalid parameter";
+        case GPU_ERROR_API_FAILED: return "API call failed";
+        default: return "Unknown error";
+    }
+}
+
+bool gpu_vendor_supported(gpu_vendor_t vendor) {
+    switch (vendor) {
+        case GPU_VENDOR_NVIDIA:
+        case GPU_VENDOR_AMD:
+        case GPU_VENDOR_INTEL:
+            return true;
+        default:
+            return false;
+    }
+}