Bilder transformieren mit Code – in nativer Geschwindigkeit.

Hör auf zu raten. Fang an zu sehen. MLC OpticScript ist die professionelle Entwicklungsumgebung für Bildverarbeitung. Kombiniere die Flexibilität von JavaScript mit der Performance einer nativen Engine und der Intelligenz lokaler KI-Modelle.

Eine blitzschnelle Engine, JavaScript-Power und lokale KI-Modelle in einem Paket.

Schreib ein paar Zeilen Code und erledige in Millisekunden, wofür andere teure Software brauchen:

• KI-Background-Removal: Motive freistellen ohne Daten-Upload.
• KI-Gesichtsrestaurierung (GFPGAN): Unscharfe, niedrig aufgelöste oder alte gescannte Gesichter wiederbeleben — vollständig auf dem Gerät. Im optionalen KI-Tools-Paket (Windows).
• Face-Detection: Gesichter finden, markieren oder mit einem Befehl verpixeln.
• KI-Upscaling (Real-ESRGAN 4×): Deine Bilder auf Knopfdruck knackscharf vergrößern. Im optionalen KI-Tools-Paket (Windows).
• Live-Playground: Sieh jede Änderung sofort. Vergleiche verschiedene Algorithmen (wie Denoising oder Filter) direkt nebeneinander in der Galerie-Ansicht.

Der schlanke Basis-Installer (~156 MB) enthält die Engine plus die leichten Tools (rmbg, Face-Detection). GFPGAN-Restaurierung und Real-ESRGAN-Upscaling stecken in einem separaten KI-Tools-Paket (~250 MB), das du jederzeit nachinstallieren kannst. Wer alles in einem Download will, nimmt die Komplett-Variante (~406 MB).

Kein "Python-Chaos", kein kompliziertes Setup, kein Warten. Einfach Code.

🚀 Skripte werden zu Werkzeugen

Du hast den perfekten Workflow im Playground gebaut? Mit dem mlcos-compile Befehl machst du daraus ein echtes Tool.Deine JavaScript-Variablen werden automatisch zu Kommandozeilen-Argumenten.

So wird aus einem kreativen Experiment ein robustes Werkzeug für dein Team oder deine Kunden:

Dein kompiliertes Skript direkt in der Konsole nutzen:

my-tool.exe --input "photo.jpg" --noise_amount 0.5 --output "clean.webp"

Keine Runtime-Abhängigkeiten, kein Node.js oder Python beim Endnutzer nötig.

Skripte schreiben, Ergebnisse sofort sehen

Der Desktop-Playground bietet einen Code-Editor mit Live-Vorschau. Bild(er) reinziehen, ein paar Zeilen JavaScript schreiben und das Ergebnis in der Vorschau sehen. Parameter-Slider erlauben Feintuning ohne Code-Anpassung. Scripte können exportiert werden und später einfach per namen wieder verwendet werden.

• 35+ Operationen — Blur, Sharpen, Rotate, Warp, Blend, Farbkorrektur, Kantenerkennung
• Verkettbare API — img.brightness(1.2).blur(2).rotate(45).resize(800, 600)
• Multi-Output — mehrere Ergebnisbilder aus einem einzigen Skript
• Galerie-Ansicht — Outputs nebeneinander vergleichen mit Zoom

Vektorgrafik trifft Rasterverarbeitung

Pfade, Formen und Verläufe auf einem Canvas zeichnen und auf Rasterbilder übernehmen. SVG-Dateien importieren oder Rasterbilder nach SVG umwandeln — alles aus unserer Engine heraus.

Warpen, Verzerren und Perspektiv-Transformationen

Das WarpGrid-System erlaubt ein Kontrollpunkt-Gitter zu definieren und Bilder mit Sub-Pixel-Präzision zu verzerren. Fotos auf 3D-Oberflächen wie Würfel platzieren, Tonnenverzerrungen oder künstlerische Deformationen erstellen — mit wenigen Zeilen Code.

Vom Screenshot zum fertigen Handbuch – in Sekunden.

Dokumentation muss nicht mühsam sein. Mit MLC OpticScript automatisierst du den gesamten Prozess:

• Automatisches Mockup-Warping: Platziere deine Screenshots perspektivisch korrekt auf Laptop- oder Monitor-Grafiken – ohne Photoshop.
• KI-Anonymisierung: Verpixle Gesichter oder sensible Daten in deinen Screenshots vollautomatisch per face-detect.
• Batch-Processing: Erstelle hunderte Handbuch-Grafiken in einem Rutsch. Einmal das Skript schreiben, immer wieder verwenden.

Bilder auf beliebige Flächen projizieren (Warp)

Mit Perspektiv-Transformationen jedes Bild auf jede Oberfläche platzieren. Einen Screenshot auf ein gebogenes Monitor-Mockup mappen, ein Foto um einen 3D-Würfel wickeln oder Artwork auf eine rotierende Trommel projizieren — alles in Echtzeit berechnet.

// Screenshot auf ein Monitor-Mockup platzieren
const screen = Engine.loadImage("SCREENSHOT");
const mockup = Engine.loadImage("MONITOR");
screen.warp4(
  [120, 80],  [540, 95],   // oben-links, oben-rechts (auf dem Monitor)
  [530, 370], [130, 355]   // unten-rechts, unten-links
);
mockup.blendAt(screen, 0, 0, { mode: BLEND_OVER });

Das WarpGrid-System geht noch weiter: ein Kontrollpunkt-Gitter definieren und Tonnenverzerrungen, Seitenknicke, zylindrische Wicklungen oder beliebige Freiform-Deformationen erzeugen.

Animationen und Hintergrundentfernung

Mehrbild-Animationen aus einem einzigen Skript bauen — Fade-Ins, Slide-Ins, Montagen — und als APNG oder animiertes WebP exportieren, das in jedem modernen Browser oder Image-Viewer nativ abgespielt wird. Der Animation-Container kümmert sich automatisch um Frames außerhalb der Leinwand, also brauchen Slide-from-Edge-Effekte keinen Sondercode.

const anim = Engine.animation(800, 600, { loop: 0 });
const src  = Engine.loadImage(HERO);
for (let i = 0; i < 20; i++) {
  const frame = src.clone().brightness(i / 19);
  anim.addFrame(frame, { delay: 50 });
  frame.free();
}
anim.saveWebP(OUTPUT, { lossy: true, quality: 85 });

Für die Hintergrundentfernung gibt es zwei komplementäre Wege:

• rmbg — KI-gestütztes Freistellen für Foto-Motive. Das KI-Modell läuft direkt auf dem Gerät; keine Cloud-Anfragen, kein Upload, keine Kosten pro Bild. Das 4.4 MB grosse Modell (Apache-2.0) wird mit dem Binary mitgeliefert.
• removeWhiteBackground() — für Skizzen und Strichzeichnungen auf weißem Papier, wo die KI kein klares Motiv findet. Drei Stellschrauben (Threshold, Feather, optionaler harter Schnitt), läuft in Millisekunden, kein Modell.

Plugin- und Extension-System

OpticScript hat zwei Erweiterungs-Schichten, beide ohne Engine- Recompile nutzbar:

KI schon dabei!

Mehrere Modelle, null Cloud-Kosten — OpticScript bringt die Intelligenz direkt auf deinen Rechner. Die Modelle sind optimiert, klein und laufen nativ:

• rmbg: Präzises Freistellen von Objekten und Personen.
• gfpgan-restore: Gesichtsrestaurierung — unscharfe, niedrig aufgelöste oder alte gescannte Gesichter wiederbeleben.
• face-detect: Erkennt Gesichter für automatische Zensur oder Fokus-Effekte.
• upscale: Rettet niedrig aufgelöste Bilder mit 4x ESRGAN-Power.

Du kannst auch unser Text-zu-Bild-Tool nativ anbinden.

Tool Plugins — beliebige CLIs einbinden

Ein Tool Plugin beschreibt ein externes Binary in einer manifest.json (Executable-Pfad, Input/Output-Slots, Parameter-Platzhalter) und die Engine spawnt es bei Bedarf. Bilddaten fließen durch ein Per-Call-Temp- Verzeichnis — jedes Programm, das Bilddateien liest/schreibt, wird zur skriptbar Funktion.

const cut = Engine.tool('rmbg').apply(img, { threshold: 0.0 });

Einsatzbereite Plugins — alle im Basis-Installer enthalten, sofern nicht anders gekennzeichnet:

• rmbg — KI-gestützte Hintergrundentfernung (~16 MB Modell direkt auf dem Gerät, kein API-Key, kein Server, keine Netzwerkverbindung).
• gfpgan-detect — Gesichtserkennung mit 3-Punkt-Landmarks (Augen + Nase). Partner-Tool für gfpgan-restore.
• gfpgan-restore — GFPGAN-Gesichtsrestaurierung; unscharfe, niedrig aufgelöste oder alte gescannte Gesichter wiederbeleben. Keine Cloud, kein Upload. Im KI-Tools-Paket (~250 MB, Add-on unter Windows).
• facedetect — schnelle Gesichtserkennung für Auto-Blur oder Fokus-Effekte.
• mlcupscale — 4× Real-ESRGAN-Upscaling, Modelle ins Binary eingebettet — kein Vulkan, kein separater Modell-Download. Im KI-Tools-Paket (~250 MB, Add-on unter Windows).
• stitch-gif — fügt mehrere Bilder mit einem einzigen Skript- Aufruf zu einem animierten GIF zusammen.
• frame — minimales Referenz-Plugin als Vorlage für eigene Erweiterungen (~10 Zeilen Code).

Plus ein optionales:

• mlcsd-txt2img — Bridge zu einem lokalen Stable-Diffusion- HTTP-Server (mlc-stablediffusion). Schickt den Prompt durch dessen OpenAI-kompatiblen Endpoint und füttert das erzeugte Bild direkt zurück ins Skript — Text-to-Image-Generation direkt in einer OpticScript-Pipeline:

  const sd = Engine.tool('mlcsd-txt2img').apply(
    { prompt: "ein Café im Regen bei Nacht, Neon-Reflexionen",
      model: "z-image-turbo", seed: 42 });
  sd.brightness(1.05).vignette(0.3).save(OUTPUT);
  

Engine-Extensions — interne JS-Module

Schwerere "Custom"-Mathematik oder Filter-Ketten können in TypeScript geschrieben und in die QuickJS-Runtime als Erweiterung( Engine-Extensions) geladen werden. Sie werden zu "First-Class-Methoden" auf Engine.* und sind von jedem Skript importierbar, ohne das Binary neu auszuliefern. Die mitgelieferte cube-Extension ist ein kleines Beispiel; der volle Authoring-Guide steht in docs/extensions/.

Beide Schichten sind beim Installer dokumentiert und im Playground über die Tools- / Extensions-Tabs entdeckbar.

Zwischen Raster und Vektor konvertieren

Jedes Rasterbild nach SVG umwandeln — mit voller Kontrolle über Farbanzahl, Pfadvereinfachung, Speckle-Filter und mehr. Umgekehrt SVG-Dateien in beliebiger Skalierung rendern.

// Raster → SVG
const svg = img.toSVG({ colorCount: 24, pathSimplify: "spline" });
Engine.writeSVG("OUTPUT_SVG", svg);

// SVG → Raster (2x Skalierung für Retina)
const rendered = Engine.loadSVG("logo.svg", 2.0);

Batch-Verarbeitung und Automatisierung

Das CLI-Tool mlcos verarbeitet Bilder in Skripten und CI-Pipelines. Der HTTP-Server mlcos-server stellt dieselbe Engine als REST-API bereit. Oder JavaScript in eine eigenständige Binary kompilieren mit mlcos-compile.

Mit unseren eigenen Tools erstellt

Das Hero-Bild auf dieser Seite wurde vollständig mit MLC-Software erstellt:

• Hintergrundszene — generiert mit Z-Image, unserem On-Device Text-zu-Bild-Modell auf Apple Silicon. Keine Cloud, kein API-Key.
• Screenshot-Platzierung — der Playground-Screenshot wurde mit OpticScripts stampAt() Perspektiv-Transformation auf den Laptop-Bildschirm gewarpt, gesteuert per mlcos-run von der Kommandozeile.

Zwei Befehle. Das ist der Punkt.

Gebaut für Performance

Jede Pixel-Operation läuft in nativer Geschwindigkeit — keine externen Programme werden gestartet, kein Python-Interpreter, keine Zwischendateien zwischen Tools. Eine Perspektiv-Transformation auf einem 4K-Bild dauert Millisekunden, nicht Sekunden.

Format-Abdeckung auf einen Blick

• Eine Binary, alle Formate. Keine System-Bibliotheken, keine System-Fonts, kein Python, kein Node. Die kompilierte .exe trägt alles (libwebp, libpng, libtiff, libavif, resvg, vtracer) statisch gelinkt mit sich.
• EXIF-Round-Trip — meta.exif.* wird automatisch von Engine.loadImage() befüllt; die Werte bleiben über die ganze Kette erhalten und werden beim JPEG-Save wieder ins Bild gestempelt.
• Animationen Frame für Frame bauen mit Engine.animation(w, h, { loop: 0 }), dann als einzelne APNG- / WebP- / TIFF-Datei exportieren — jeder moderne Browser und Bild-Viewer spielt sie nativ ab.
• Vektor-Loop — beliebiges Raster mit vtracer nach SVG tracen, beliebiges SVG mit resvg zurück nach Raster rendern, alles ohne das Skript zu verlassen.