Gnuplot ist ein skript- und kommandozeilengesteuertes Programm zur grafischen Darstellung von Messdaten und mathematischen Funktionen. Entwickelt seit 1986 von Thomas Williams und Colin Kelley (aktuelle Hauptversion 5.x), läuft gnuplot auf praktisch jedem System und exportiert in PNG, SVG, PDF, LaTeX, PostScript und viele weitere Formate.

Start und Ausführung

gnuplot                 # interaktive Kommandozeile
gnuplot -p plot.gp      # Skript ausführen, Fenster offen lassen
gnuplot -e "plot sin(x)"   # Einzeiler
gnuplot -persist        # Fenster nach Skript-Ende halten

Wichtige Befehle

• Plots erzeugen: plot (2D), splot (3D), replot (letzte Zeichnung wiederholen), refresh
• Daten: plot 'daten.txt' using 1:2 with linespoints, plot 'daten.csv' using 1:2:3 with errorbars
• Optionen setzen: set, unset, show (z.B. set grid, set logscale y, show terminal)
• Achsen/Beschriftung: set xlabel 'Zeit', set ylabel 'Amplitude', set title 'Messreihe', set xrange [0:10]
• Ausgabe: set terminal png, set output 'plot.png', set term pdf
• Kurvenanpassung: fit f(x) 'daten.txt' via a, b

Beispiel-Skript

set terminal pngcairo size 800,600
set output 'sinus.png'
set title 'Sinus und Cosinus'
plot sin(x) title 'sin' with lines, cos(x) title 'cos' with lines
set output   # Datei schließen

Daten inline übergeben

plot '-' using 1:2 with lines
0 0
1 1
2 4
3 9
e

Das e beendet die Inline-Daten; praktisch für schnelle Tests ohne Datei.

Praxis-Tipps

• Skripte mit .gp-Endung speichern und per gnuplot -p skript.gp reproduzierbar ausführen.
• Für wissenschaftliche Publikationen: set terminal postscript eps oder set terminal cairolatex.
• Mit set style data linespoints den Standard-Stil für alle Plots setzen.

Verwandte Grundlagen: Octave-Befehle und Scilab-Befehle nutzten gnuplot historisch als Grafik-Backend; Python-Befehle (matplotlib) und R-Befehle bieten ähnliche Plot-Funktionen.

WebGPU ist der W3C-Standard für GPU-Programmierung im Browser und ersetzt WebGL. Der Entwurf wurde 2023 als W3C-Kandidatenempfehlung veröffentlicht; Chrome, Edge, Firefox und Safari liefern die API inzwischen aus. WebGPU ist bewusst modern gestaltet: Sie bildet nativ auf Vulkan, Metal und Direct3D 12 ab und bringt erstmals Compute-Shader in den Browser — etwa für Machine-Learning-Inferenz und Physik-Simulationen.

Adapter und Device

Der Einstieg erfolgt asynchron über das navigator.gpu-Objekt:

const adapter = await navigator.gpu.requestAdapter();
const device = await adapter.requestDevice();

Der Adapter repräsentiert die physikalische GPU, das Device die logische Schnittstelle, über die alle Ressourcen erzeugt werden. Ist kein Adapter verfügbar (etwa ohne GPU), liefert requestAdapter() null — dann muss der Code einen Fallback bieten.

Shader in WGSL

Statt GLSL verwendet WebGPU die WebGPU Shading Language (WGSL). Shader werden als Modul kompiliert:

const module = device.createShaderModule({
  code: `@vertex fn vs_main() -> @builtin(position) vec4<f32> { ... }`
});

Pipeline und Render-Pass

const pipeline = device.createRenderPipeline({
  layout: 'auto',
  vertex: { module, entryPoint: 'vs_main' },
  fragment: { module, entryPoint: 'fs_main', targets: [{ format: 'bgra8unorm' }] }
});
const encoder = device.createCommandEncoder();
const pass = encoder.beginRenderPass({ colorAttachments: [...] });
pass.setPipeline(pipeline);
pass.draw(3, 1, 0, 0);
pass.end();
device.queue.submit([encoder.finish()]);

Ressourcen wie Puffer und Texturen entstehen über createBuffer() beziehungsweise createTexture(); Bind-Groups (createBindGroup()) koppeln Shader-Ressourcen an die Pipeline. Compute-Pipelines nutzen createComputePipeline() und dispatchWorkgroups().

Implementierungen

• Dawn: Googles C++-Implementierung, Grundlage von Chromium und vielen nativen Projekten.
• wgpu: Rust-Implementierung, unter anderem in Firefox und in Rust-Spiele-Engines wie Bevy.
• Über Dawn und wgpu läuft WebGPU-Code auch nativ außerhalb des Browsers — gleiche Shader, gleiche API.

Verwandte Themen: JavaScript-Befehle, Metal-Befehle, Vulkan-Befehle.

Metal ist die Low-Level-Grafik- und Compute-API von Apple für iOS, macOS, iPadOS und tvOS. Sie wurde 2014 mit iOS 8 und OS X Yosemite eingeführt und ersetzt auf Apple-Plattformen nach und nach OpenGL: Ab macOS 10.14 Mojave (2018) gilt OpenGL als veraltet. Metal erlaubt direkten Zugriff auf die GPU und gilt als Gegenstück zu Vulkan, Direct3D 12 und WebGPU.

Kernobjekte

Die Metal-API ist objektorientiert aufgebaut. Die wichtigsten Typen:

• MTLDevice: Repräsentiert die GPU; Einstiegspunkt ist MTLCreateSystemDefaultDevice().
• MTLCommandQueue: Verwaltet die Warteschlange der Kommandos (makeCommandQueue()).
• MTLCommandBuffer: Sammelt alle Encoder-Aufrufe eines Frames (makeCommandBuffer()).
• MTLRenderCommandEncoder: Zeichnet Geometrie, setzt Pipeline und Ressourcen (makeRenderCommandEncoder()).
• MTLRenderPassDescriptor: Beschreibt Ziel-Farb- und Tiefenpuffer des Render-Passes.

Pipeline aufbauen

Shaders werden in der Metal Shading Language (MSL) geschrieben, einer auf C++11 basierenden Sprache, die von LLVM und Clang übersetzt wird. Der Ablauf:

// Kompilieren im Terminal
xcrun metal -c shader.metal -o shader.air
xcrun metallib shader.air -o default.metallib

Zur Laufzeit lädt man die Bibliothek (makeLibrary()), beschreibt ein MTLRenderPipelineDescriptor mit Vertex- und Fragment-Funktion und erzeugt die Pipeline per makeRenderPipelineState(). Danach werden Vertex-Puffer über setVertexBytes() beziehungsweise setVertexBuffer() gebunden und mit drawPrimitives() gezeichnet.

Compute-Shader

Neben Grafik unterstützt Metal auch GPU-Compute: Ein MTLComputeCommandEncoder setzt die Kernel-Funktion (setComputePipelineState()) und verteilt die Arbeit über dispatchThreadgroups(). Damit lassen sich Bildverarbeitung, Simulationen und Machine-Learning-Aufgaben direkt auf der GPU ausführen. Metal 4 (WWDC 2025) integriert Tensoren als Datenstrukturen direkt in die API und die Shading-Sprache.

Werkzeuge

• Xcode: integrierter Metal-Debugger, Frame-Capture und Metal System Trace.
• Metal Performance Shaders: vorgefertigte, optimierte Kernels für Bild- und Matrixoperationen.
• MetalFX: Upscaling- und Temporal-Anti-Aliasing-Technik für Spiele.

Verwandte Themen: OpenGL-Befehle, HLSL-Befehle, C/C++-Befehle.

WebGL (Web Graphics Library) ist eine JavaScript-API der Khronos Group für hardwarebeschleunigte 2D- und 3D-Grafik im Browser — ohne Plugins. WebGL 1.0 erschien im März 2011 und basiert auf OpenGL ES 2.0; WebGL 2.0 folgte im Januar 2017 auf Basis von OpenGL ES 3.0. Die API wird von allen modernen Browsern unterstützt und ist die Grundlage vieler Frameworks wie Three.js und Babylon.js. Als moderne Weiterentwicklung gilt WebGPU.

Kontext erzeugen

WebGL läuft in einem HTML-Canvas. Der Zugriff erfolgt über getContext():

const canvas = document.getElementById('scene');
const gl = canvas.getContext('webgl');      // WebGL 1.0
const gl2 = canvas.getContext('webgl2');    // WebGL 2.0

Ohne GPU-Unterstützung liefert der Aufruf null zurück — das sollte vor dem Rendern geprüft werden.

Shader und Programm

WebGL verwendet Shader in GLSL ES, die als Strings an die GPU übergeben werden:

const vs = gl.createShader(gl.VERTEX_SHADER);
gl.shaderSource(vs, vertexShaderSource);
gl.compileShader(vs);
const prog = gl.createProgram();
gl.attachShader(prog, vs);
gl.linkProgram(prog);
gl.useProgram(prog);

Die Shader-Quelltexte werden zur Laufzeit kompiliert; Fehler lassen sich über getShaderInfoLog() beziehungsweise getProgramInfoLog() auslesen.

Geometrie zeichnen

Vertex-Daten liegen in GPU-Puffern. Der typische Zeichenablauf:

const buf = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, buf);
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW);
gl.vertexAttribPointer(loc, 3, gl.FLOAT, false, 0, 0);
gl.enableVertexAttribArray(loc);
gl.clearColor(0.1, 0.1, 0.1, 1.0);
gl.clear(gl.COLOR_BUFFER_BIT);
gl.drawArrays(gl.TRIANGLES, 0, 3);

Wichtige Draw-Funktionen sind drawArrays() für nicht-indizierte und drawElements() für indizierte Geometrie. Texturen werden über createTexture(), texImage2D() und bindTexture() verwaltet.

Einschränkungen

• WebGL 1.0 kann nur Vertex- und Fragment-Shader (keine Geometry- oder Compute-Shader).
• Die API ist zustandsbehaftet (State-Machine) wie OpenGL; viele Frameworks kapseln das.
• WebGL 2.0 bringt Textur-Arrays, Instancing, Uniform Buffer Objects und erweiterte MRTs.

Verwandte Themen: JavaScript-Befehle, GLSL-Befehle, OpenGL-Befehle.