Zum Inhalt springen
Sealpixel
en

Klein bearbeiten. Groß rendern. Beweisen.

Aus dem Edit-Log wird das C2PA-Manifest. Dein Schlüssel signiert es. Deine Nutzer bearbeiten eine Arbeitskopie im Browser; dein Backend rendert dasselbe Log auf dem 80-Megapixel-Original, mit demselben Core wie der Browser. Gleiches Original, gleiches Log, gleiche Bytes, per Hash geprüft.

Alles hier unten ist CSS. Kopieren, in deine App einfügen, fertig.

Preset
<sealpixel-editor theme="dark" locale="de">

Jede Bearbeitung belegt. Von dir signiert.

Ein Foto, das du veröffentlichst, trägt seine Geschichte mit: was unkenntlich gemacht wurde, was beschnitten wurde, und wer es signiert hat. Jeder kann das prüfen, im Browser, in Sekunden. Der Schlüssel bleibt bei dir. Sealpixel sieht nie einen Schlüssel.

Kein Mehraufwand für die Redaktion

Kennzeichen verpixeln, beschneiden, veröffentlichen. Der Nachweis entsteht aus den Bearbeitungen selbst. Niemand füllt ein Formular aus, nichts wird vergessen.

Dein Name steht drauf

Der Nachweis trägt deine Signatur, mit dem Schlüssel, den du ohnehin hast. Niemand signiert in deinem Namen, und eine spätere Änderung fällt auf.

Überall prüfbar

Content Credentials sind ein offener Standard. Wer das Bild in einem passenden Viewer öffnet, der öffentlichen Verify-Seite zum Beispiel, sieht die Geschichte und den Unterzeichner.

Was ein Leser sieht
  • Signiert von deiner Organisation
  • Bearbeitet: ein Bereich unkenntlich gemacht, verpixelt
  • Beschnitten
  • Original: dsc-4821
  • Bearbeitet mit Sealpixel

Die Einträge oben sind, was das Manifest unten sagt, in den Worten eines Viewers.

@sealpixel/c2pa

Die Manifest-Definition. Kostenlos, unter derselben Lizenz wie der Rest.

@sealpixel/c2pa-sign

Das Signiermodul. Provenance-Plan, pro Organisation.

Zum Provenance-Plan →So funktioniert es, für Entwickler →

Für deine Entwickler: das Edit-Log und die Manifest-Definition

Aus dem Edit-Log wird die Definition des C2PA-Manifests, eine Action pro Bearbeitung mit ihrer Region in Prozent der Ausgabe. @sealpixel/c2pa schreibt sie, kostenlos. @sealpixel/c2pa-sign signiert sie dort, wo dein Schlüssel liegt.

Das Edit-Log

{
  "version": 1,
  "source": { "id": "dsc-4821", "width": 6000, "height": 4000 },
  "ops": [
    { "type": "redact.add", "id": "r1",
      "region": { "kind": "rect",
        "rect": { "x": 0.42, "y": 0.31, "width": 0.07, "height": 0.09 } },
      "mode": "pixelate", "amount": 64 },
    { "type": "crop.set", "id": "c1",
      "rect": { "x": 0.1, "y": 0.1, "width": 0.8, "height": 0.8 } }
  ]
}

Zwei Operationen: ein Kennzeichen verpixelt, dann ein Crop.

Die Manifest-Definition

{
  "title": "result.jpg",
  "assertions": [{
    "label": "c2pa.actions",
    "data": {
      "allActionsIncluded": true,
      "softwareAgents": [{ "name": "sealpixel", "version": "1.0.0-rc.20" }],
      "actions": [
        {
          "action": "c2pa.edited",
          "description": "Region obscured: pixelate, 64 px",
          "digitalSourceType": "http://cv.iptc.org/newscodes/digitalsourcetype/humanEdits",
          "softwareAgentIndex": 0,
          "parameters": { "dev.sealpixel.redact": { "mode": "pixelate", "amount": 64 } },
          "changes": [{
            "description": "obscured (pixelate)",
            "region": [{
              "type": "spatial",
              "shape": { "type": "polygon", "unit": "percent",
                "origin": { "x": 40, "y": 26.25 },
                "vertices": [{ "x": 40, "y": 26.25 }, { "x": 48.75, "y": 26.25 },
                             { "x": 48.75, "y": 37.5 }, { "x": 40, "y": 37.5 }] }
            }]
          }]
        },
        {
          "action": "c2pa.cropped",
          "description": "Cropped to 4800 x 3200 of 6000 x 4000",
          "digitalSourceType": "http://cv.iptc.org/newscodes/digitalsourcetype/humanEdits",
          "softwareAgentIndex": 0
        }
      ]
    }
  }]
}

Zwei Actions. c2pa.edited trägt die Region, durch den Crop in Prozent der Ausgabe gerechnet; c2pa.cropped nennt den neuen Ausschnitt. Ein Viewer zeigt beides als Content Credentials.

Beweise statt Versprechen

Paritäts-Demo ansehenCI-Workflow ansehen

  • 139

    Referenz-Renderings

    Edit-Logs und Pläne mit gepinnten Hashes

  • 136

    CLI-Paritätstests

    natives Rust und Node liefern dieselben Bytes

  • 130

    Browser-Testläufe

    in 3 Engines, bei jedem Commit

  • 397 KB

    Core, komprimiert

    1,3 MB unkomprimiert, eine Binary für jede Runtime

Läuft identisch auf Chrome, Safari, Firefox, Node.js, Deno, Bun, AWS Lambda

Der Browser bearbeitet eine Arbeitskopie. Dein Backend rendert das Original.

Ab 16 Megapixeln behält der Editor standardmäßig nur eine Arbeitskopie mit höchstens 2048 px und zeigt jede Änderung darauf. Dein Backend nimmt das Edit-Log und rendert mit @sealpixel/render die volle Auflösung, mit demselben Core wie der Browser.

Im Browser

2048 × 1537

3,15-MP-Arbeitskopie. Der Browser dekodiert das Original einmal und behält nur sie.

Über die Leitung

561 Bytes

Kein Bild. Fünf Operationen in Koordinaten, die von der Auflösung unabhängig sind.

In deinem Backend

10328 × 7752

80,1 MP aus dem Original, in etwa 2.178 MB: 24 Byte pro Pixel plus 256 MB. Ohne Browser-Runtime.

Das komplette Edit-Log

561 Bytes serialisiert

{
  "version": 1,
  "source": {
    "id": "dsc-4821", "width": 10328, "height": 7752,
    "hash": "9f2a7c4e18b3d05a6e1f8c2b47d930ae5c86f1b2093d4e7a8c5b1f6d2e0a3947"
  },
  "ops": [
    { "type": "crop.set",     "id": "c1", "rect": { "x": 0.08, "y": 0.12, "width": 0.8, "height": 0.72 } },
    { "type": "finetune.set", "id": "f1", "params": { "contrast": 0.18, "saturation": 0.22 } },
    { "type": "redact.add",   "id": "r1", "region": { "kind": "rect", "rect": { "x": 0.42, "y": 0.31, "width": 0.07, "height": 0.09 } }, "mode": "pixelate", "amount": 64 },
    { "type": "filter.set",   "id": "p1", "preset": "warm", "strength": 0.4 },
    { "type": "resize.set",   "id": "s1", "width": 3000 }
  ]
}

Ein 30-MB-Original gegen die paar Bytes, die beschreiben, was damit passieren soll. Dieses Verhältnis ist die Architektur.

Dein Backend rendert, was der Browser gezeigt hat

@sealpixel/render ist ein Baustein, kein Server. Deine Route, Function oder dein Job übergibt die Bytes des Originals und das Edit-Log. Der Renderer prüft beides, rendert mit derselben WebAssembly-Binary wie der Browser und liefert Bytes, Hash, Größe und Timings. Routing, Speicher und Retries bleiben in deinem Code.

  • Limits vor dem Decode: Dateigröße, Pixelzahl aus dem Header, Log-Größe
  • Das Log gehört zu seinem Original: Ein anderer SHA-256 oder eine andere Größe wird abgelehnt
  • Gleiche Plugins, gleiche Optionen: Ein Log, das die Regeln des Editors bricht, wird abgelehnt
  • Kein Routing, kein CORS, kein Speicher: Du übergibst jedes Byte, auch die Fonts

In der Demo ausprobieren →Zum Render-Guide →

import { createRenderer, estimateMemoryMB } from '@sealpixel/render';
import { defaultPlugins } from '@sealpixel/plugins';

// Once per process, in your own route, function or job.
const renderer = createRenderer({
  plugins: defaultPlugins,         // the list the editor registers
  limits: { maxMegapixels: 100 },  // default 80; this photo has 80.1
});

const { log, index } = saved;      // from the editor's getEditLog()
const result = await renderer.render({
  original,                        // Uint8Array, byte for byte
  editLog: log,
  upTo: index,
  output: { format: 'image/jpeg', quality: 0.92 },
});
// { bytes, stream(), hash, width, height, mimeType, timings }
// result.hash equals a browser export of the same original and log

estimateMemoryMB(10328, 7752);     // 2178

Eine Komponente. Drei Produkte.

Dasselbe Element mit anderen Plugins, Themes und Sprachen. Kein Fork, kein Build-Step: nur Attribute und CSS.

Profilbild

Ein Sign-up-Flow: rund zuschneiden, aufhellen, fertig. Zwei Tools, helles Theme, kein Export-Button; exportiert wird nur der Kreis.

Marketing-Studio

Ein Content-Team baut Kampagnenbilder: alle Tools, dunkles Graphit, runde Buttons.

Compliance-Desk

Ein Compliance-Team verpixelt personenbezogene Daten in gescannten Formularen. Schwärzen, Zeichnen, Wasserzeichen, High-Contrast-Theme, deutsche Oberfläche.

Auf dem Handy genauso gut wie am Desktop.

Dieselbe Komponente passt sich auf dem Smartphone von selbst an. Kein zweites UI, kein Mobile-Flag. Probier es direkt im Frame aus.

  • Eine Komponente, zwei Layouts

    Unter 768 px Containerbreite rutscht die Toolbar nach unten, das Tool-Panel sitzt direkt darüber. Entscheidend ist der Container, nicht der Viewport. Eine schmale Sidebar bekommt also auch das Handy-Layout.

  • Touch first

    Pinch zum Zoomen, Ziehen zum Verschieben, ein Finger für Crop-Handles, Schwärzungen und Zeichnungen. Am Desktop machen Mausrad und Trackpad dasselbe.

  • Einmal dekodieren, dann Ruhe

    Das Handy dekodiert das Bild einmal und arbeitet aus dem Speicher. Kein erneuter Upload zwischen den Tools, kein Roundtrip für eine Vorschau. Das merkt man am Akku.

  • Notch und Home-Indicator

    Safe-Area-Insets werden respektiert. show-history="buttons" blendet die Timeline aus, show-export="never" den Export-Button. So passt das Wesentliche auf einen kleinen Screen.

Live-Editor im Handy-Frame. Ziehen, pinchen, tippen.

Das Edit-Log ist das Bild

Beweisen, was sich geändert hat

Jede Unkenntlichmachung und jeder Beschnitt wird beim Bearbeiten festgehalten, und dein eigener Schlüssel signiert den Nachweis. Ein Leser prüft ihn im Browser. Sealpixel sieht nie einen Schlüssel.

Ein Log, ein Core

Jeder Crop, jeder Filter, jede Zeichnung ist eine Operation in einem JSON-Log. Ein Rust-Core, kompiliert zu WebAssembly, führt es aus: im Web Worker, auf Node, Deno, Bun oder AWS Lambda. Gleiche Bytes rein, gleiche Bytes raus.

Byte-identisch, per Hash geprüft

Gleiche Quelle, gleiches Log, egal wo gerendert: Der SHA-256 stimmt. Im Browser, auf Node, Deno, Bun oder in einer Lambda.

Weitermachen aus JSON

Das Original einmal speichern, das Log daneben. Jeden Zustand auf jedem Gerät wieder öffnen, ohne Qualitätsverlust. Das Log kann im exportierten PNG, JPEG oder WebP mitreisen.

Alle Tools, die deine Nutzer erwarten

Elf Plugins in der Reihenfolge der Toolbar, jedes ein eigenes Paket. Jedes lässt sich weglassen, ersetzen oder erweitern.

  • Zuschneiden

    Auf ein Seitenverhältnis schneiden, frei drehen, spiegeln.

    @sealpixel/plugin-crop
  • Feinabstimmung

    Helligkeit, Kontrast, Sättigung, Belichtung, Gamma, Klarheit und Vignette regeln.

    @sealpixel/plugin-finetune
  • Filter

    Graustufen, Sepia, Vintage, Kalt, Warm oder jede 4×5-Farbmatrix anwenden, in jeder Stärke.

    @sealpixel/plugin-filter
  • Assistent

    Opt-in

    Dein eigener Detektor schlägt Bereiche im Browser vor; ein Mensch bestätigt, ins Log kommen normale Schwärzungen.

    @sealpixel/plugin-assist
  • Schwärzen

    Rechtecke und Freiformen verpixeln oder weichzeichnen, mit Zellen im Raster des Originals.

    @sealpixel/plugin-redact
  • Zeichnen

    Rechtecke, Ellipsen, Linien, Pfeile, Freihand und Text zeichnen, alles nachträglich verschiebbar.

    @sealpixel/plugin-annotate
  • Sticker

    Logos und Bild-Assets platzieren, in jedem Winkel und jeder Deckkraft.

    @sealpixel/plugin-sticker
  • Rahmen

    Einen Voll-, Innen- oder Polaroid-Rahmen setzen.

    @sealpixel/plugin-frame
  • Wasserzeichen

    Bild oder Text in eine Ecke oder gekachelt stempeln, im Backend-Render identisch.

    @sealpixel/plugin-watermark
  • Größe

    Die Ausgabe auf eine Zielgröße bringen: Contain, Cover oder Fill, Lanczos3 beim Verkleinern, Catmull-Rom beim Vergrößern.

    @sealpixel/plugin-resize
  • Füllung

    Kein Button in der Toolbar

    Flächen färben, die beim Drehen oder Zuschneiden frei werden.

    @sealpixel/plugin-fill

Eine Komponente für jeden Stack

Unten eine Web Component, oben dünne, typisierte Wrapper. Controlled und uncontrolled Edit-Logs überall.

Auf deinem Server rendern

Ein Baustein, kein Server: Du rufst ihn in deiner eigenen Route, Function oder deinem Job auf. Node 24+, Deno, Bun und AWS Lambda.

In StackBlitz öffnen
import { readFile } from 'node:fs/promises';
import { DEFAULT_FONT, defaultPlugins } from '@sealpixel/plugins';
import { createRenderer } from '@sealpixel/render';

// The renderer reads no file. You pass every byte, the font too.
const font = new Uint8Array(await readFile(new URL(DEFAULT_FONT.url)));

// Once per process. Your route, function or job calls render() per request.
const renderer = createRenderer({
  plugins: defaultPlugins,
  assets: [{ id: DEFAULT_FONT.id, bytes: font }],
});

const { bytes, hash } = await renderer.render({ original, editLog: log, upTo: index });

Für Entwickler gebaut, und so dokumentiert

Headless Core, typisiertes Edit-Log, ein Plugin-SDK mit Testing-Kit und Docs mit Live-Editoren auf jeder Seite.

Dasselbe Edit-Log in deinem Framework

<script type="module">
  import '@sealpixel/element';
  const editor = document.querySelector('sealpixel-editor');
  editor.src = '/photo.jpg';
  editor.addEventListener('sealpixel:process', (e) => {
    const { bytes, hash } = e.detail; // the same hash @sealpixel/render produces
  });
</script>

<sealpixel-editor theme="auto" locale="en"></sealpixel-editor>

In StackBlitz öffnen

Sieht aus wie deine App

CSS Custom Properties für jede Farbe, jeden Radius, jede Größe. ::part() erreicht Buttons, Nav und Stage. Fünf Themes und sechs Sprachen sind dabei.

  • 25

    Design-Tokens

  • 18

    Shadow-Parts

  • 5

    Themes

  • 6

    Sprachen

@import '@sealpixel/ui/themes/nocturne.css';

sealpixel-editor {
  --sealpixel-color-accent: #b48cff;
  --sealpixel-radius: 16px;
  --sealpixel-toolbar-size: 72px;
}

sealpixel-editor::part(export) { display: none; }
sealpixel-editor::part(tool) { border-radius: 999px; }

Customizer öffnen

Erweitern statt forken

Ein Plugin ist ein npm-Paket: Operationen mit Zod-Schemas, ein Reducer, ein Kernel in JavaScript oder in Rust als eigenes WebAssembly-Modul, optional ein Tool mit Panel und Gizmo. Es läuft auf Client und Server, ohne dass der Core neu gebaut wird.

Plugin anlegen

npm create @sealpixel/plugin acme-spotlight -- --kernel wasm-rust
cd acme-spotlight && npm test   # parity: Node vs Chromium, WebKit, Firefox

Paritäts- und Fuzz-Testing-Kit inklusive ·Plugin-SDK

Im Vergleich

Angaben von den öffentlichen Seiten der Anbieter, Stand September 2026; die C2PA-Zeile geprüft am 2. November 2026.

SealpixelPinturaIMG.LY CE.SDK
C2PA-Manifest aus dem Edit-LogJa, signiert mit deinem eigenen SchlüsselUnbekannt, nicht auf ihren SeitenUnbekannt, nicht auf ihren Seiten
QuellcodeSource available: lesen, ändern, weitergebenClosed Source, private npm-RegistryClosed Source, Escrow für Enterprise
Server-Rendering@sealpixel/render auf Node, Deno, Bun, Lambda, ohne BrowserJa, mit Browser-RuntimeNode.js
Byte-identische Ausgabe auf Client und ServerJa, per Hash geprüftNeinGleiche Engine, aber nicht als Garantie veröffentlicht
Serialisierbarer Edit-StateEdit-Log, typisiert und validiertimageState-ObjektScene-Datei
Plugin-SDK für DritteJS- und Rust-KernelFestes SetPlugin-API
React, Vue, Svelte, AstroJa, plus Web ComponentJa, plus Angular, jQueryJa, plus native Mobile-SDKs
Preis unter 1 Mio. EUR UmsatzKostenlos169 € pro Jahr, ein ProduktNur auf Anfrage
Preis pro Entwickler und Jahr999 €749 €Nur auf Anfrage
Geld-zurück-Frist30 Tage60 Tage30 Tage Trial

Kostenlos für Menschen. Fair für Unternehmen.

Eine Regel: Unter einer Million Jahresumsatz zahlst du nichts. Darüber zahlst du pro Entwickler, der am Code arbeitet.

Klein

Kostenlos

unter 1.000.000 EUR Jahresumsatz

Für Einzelpersonen und Unternehmen unter der Schwelle, im Produktiveinsatz und in kommerziellen Produkten.

  • Der ganze Editor, jeder Wrapper und das Render-Paket
  • Jedes Release
  • Community-Support auf GitHub
Loslegen

Unternehmen

999 €

pro Developer-Seat und Jahr, netto

Ab 1.000.000 EUR Jahresumsatz. Ein Seat pro Entwickler, der am Code arbeitet; übertragbar, für jedes Produkt und jede Umgebung.

  • Zwölf Monate Updates und E-Mail-Support
  • Jedes erhaltene Release bleibt für immer deins
  • 30 Tage Geld-zurück-Garantie

Kauf auf die Firma? Firmenname und USt-IdNr. tragen Sie im Checkout unter „Add VAT number“ ein, damit sie auf der Rechnung stehen.

Provenance

7.490 €

pro Organisation und Jahr, netto

Signieren in Produktion mit @sealpixel/c2pa-sign, Seats inklusive. Immer kostenpflichtig, unabhängig vom Umsatz; die Manifest-Definition in @sealpixel/c2pa bleibt kostenlos.

  • @sealpixel/c2pa-sign in Produktion
  • Vier Developer-Seats, die Einstiegsstufe; weitere zum Preis der Stufe, die deine Gesamtzahl erreicht
  • Zusicherung, dass das Action-Mapping der C2PA-Spezifikation in der Version entspricht, die die Docs nennen
  • Vorrang für Änderungen, die die Spezifikation erzwingt
  • Hilfe bei c2patool oder c2pa-rs, und E-Mail-Support

Business Source License 1.1 ohne die kostenlose Stufe. Die Sealpixel Provenance License ist ihre kommerzielle Lizenz. Lizenz lesen

Kauf auf die Firma? Firmenname und USt-IdNr. tragen Sie im Checkout unter „Add VAT number“ ein, damit sie auf der Rechnung stehen.

Enterprise

Auf Anfrage

ab 25 Seats

Wenn der Einkauf mehr braucht als eine Rechnung.

  • Source-Code-Escrow
  • Individuelle Konditionen und SLA
  • Purchase Orders, Rechnung und Überweisung
Sprich mit uns

Seat-Stufen

Die Stufe richtet sich nach der Gesamtzahl deiner Seats, ihr Preis gilt für jeden davon. Nachgekaufte Seats werden anteilig bis zu deinem Verlängerungsdatum abgerechnet; erreichen sie eine günstigere Stufe, gilt sie ab diesem Tag für alle Seats, anteilig für die Restlaufzeit und voll ab der nächsten Verlängerung. Bereits abgelaufene Zeit wird nicht neu berechnet.

SeatsPro Seat und Jahr, netto
1 bis 4Einstiegsstufe999 €
5 bis 9899 €
10 bis 24799 €
ab 25Sprich mit uns

Business Source License 1.1, nach vier Jahren Apache 2.0. Kein Lizenz-Check zur Laufzeit: Die Software telefoniert nie nach Hause. Lizenz lesen

Unsere Bestellabwicklung erfolgt über unseren Online-Reseller Paddle.com. Paddle ist Merchant of Record für alle unsere Bestellungen und wickelt Umsatzsteuer, GST und Sales Tax ab. Lizenzgeber der Software bleiben wir. Buyer Terms von Paddle

Fragen

Wer nutzt Sealpixel kostenlos?

Alle unter 1.000.000 EUR Jahresumsatz (brutto): Einzelpersonen und Unternehmen unterhalb dieser Schwelle. Produktiveinsatz und kommerzielle Produkte sind eingeschlossen. Der Umsatz zählt für die gesamte Unternehmensgruppe, die Tochter eines Konzerns ist also nicht kostenlos dabei. Bei Kundenarbeit entscheidet der Umsatz des Kunden: Ein Freelancer, der für ein kleines Startup baut, zahlt nichts, derselbe Freelancer für einen großen Kunden ist über dessen Seats abgedeckt.

Ich bin eine Agentur. Was zahle ich?

Einen Seat pro Entwickler, der an Codebasen mit Sealpixel arbeitet, egal für wie viele Kunden oder Produkte. Der Seat deines Entwicklers deckt seine gesamte Kundenarbeit ab. Deine Kunden brauchen keine eigenen Seats und keine, um die fertige Anwendung zu betreiben.

Wie funktionieren die Mengenstufen?

Sag uns, wie viele Seats du brauchst. 1 bis 4 Seats kosten je 999 EUR pro Jahr, 5 bis 9 je 899, 10 bis 24 je 799, und die Stufe gilt für jeden Seat, den du hältst. Später gekaufte Seats werden anteilig auf dein bestehendes Verlängerungsdatum abgerechnet; erreicht die Gesamtzahl eine günstigere Stufe, gilt sie ab dem Tag des Nachkaufs für alle Seats — anteilig für die Restlaufzeit und vollständig ab der nächsten Verlängerung. Die bereits abgelaufene Zeit wird nicht neu berechnet. Ab 25 Seats machen wir ein individuelles Angebot.

Darf ein Open-Source-Projekt Sealpixel nutzen?

Ja. Sealpixel selbst ist source available unter der Business Source License 1.1 und nicht Open Source, ein Projekt mit dieser Abhängigkeit erbt also diese Bedingungen: Beitragende unterhalb der Umsatzschwelle brauchen keine Seats, ein Unternehmen, das das Projekt entwickelt, braucht Seats für seine Entwickler, und Kopien und Forks bleiben unter der BUSL. Jedes Release wird vier Jahre nach Veröffentlichung Apache 2.0.

Ist Sealpixel Open Source?

Nein. Sealpixel ist source available unter der Business Source License 1.1. Der Quellcode ist öffentlich, du darfst ihn lesen, ändern, forken und weitergeben, und die produktive Nutzung ist unterhalb der Umsatzschwelle frei — aber die BUSL ist keine von der OSI anerkannte Lizenz, es Open Source zu nennen wäre also falsch. Vier Jahre nach Veröffentlichung wird eine Version Apache License 2.0, und diese Version ist dann Open Source im Sinne der OSI.

Was genau ist ein Entwicklerplatz?

Ein Seat gehört einer namentlich benannten Person, die Code in einem Projekt mit Sealpixel schreibt, prüft, testet oder integriert. Er kann übertragen werden, wenn die Person ausscheidet. Designer in der Codebasis und QA zählen mit. Endnutzer deiner Anwendung brauchen nie einen Seat, egal wie viele es sind, und Leute, die sie nur betreiben oder verwalten, ebenso wenig.

Darf ich ein SaaS auf Sealpixel bauen?

Ja. Die einzige Grenze ist ein Dienst, dessen Hauptwert der Bildeditor selbst ist, etwa ein gehostetes „Bearbeite dein Bild“-Produkt oder eine an Dritte verkaufte Bildbearbeitungs-API. Ein Fotobuch-Shop, ein CMS, ein Immobilienportal oder ein Support-Tool mit eingebauter Bearbeitung sind in Ordnung.

Bei wem kaufe ich eigentlich, und wer stellt die Rechnung?

Bei Paddle. Unsere Bestellabwicklung erfolgt über unseren Online-Reseller Paddle.com, der Merchant of Record für alle unsere Bestellungen ist: Du kaufst die Seats von Paddle, Paddle stellt die Rechnung und berechnet, erhebt und führt Umsatzsteuer, GST oder Sales Tax für dein Land ab. Gib deine USt-IdNr. im Checkout an, damit die richtige Behandlung greift. Hersteller und Lizenzgeber von Sealpixel bleiben wir — die Softwarelizenz erteilen wir nach der Developer Seat License, nie Paddle.

Wie funktioniert die Rückerstattung?

Kündige innerhalb von 30 Tagen nach dem ersten Kauf, und du bekommst den vollen Betrag zurück, auf demselben Weg, auf dem die Zahlung kam. Die Rückerstattung wickelt Paddle als unser Merchant of Record ab; schreib uns oder Paddle, wir stimmen in beiden Fällen zu. Ohne Rückfragen.

Was genau ist byte-identisch?

Dieselben Quellbytes plus dasselbe Edit-Log, gerendert mit derselben Kernversion, ergeben dieselben Ausgabebytes und denselben SHA-256, in jedem Browser, auf Node, Deno, Bun und Lambda. Ein Browser-Export und ein Render mit @sealpixel/render vom selben Original stimmen also Byte für Byte überein. Die Vorschau auf einer Arbeitskopie hat eine andere Eingabe: Die Komposition ist identisch (gleiche normalisierte Geometrie), die Bytes sind es nicht. Die Docs erklären das im Detail.

Habt ihr meinen Signierschlüssel?

Nein. Dein eigener Code signiert. Sealpixel schreibt die Manifest-Definition aus dem Edit-Log, und das Signiermodul @sealpixel/c2pa-sign läuft dort, wo dein Schlüssel liegt: Es gibt deiner Funktion die Bytes zum Signieren und nimmt die Signatur zurück. Der Schlüssel gelangt nie hinein. Sealpixel ist keine Zertifizierungsstelle und verwahrt keinen Schlüssel.

Wie groß ist der Download?

Der WebAssembly-Kern hat etwa 1,3 MB unkomprimiert und 397 KB mit Brotli und wird erst geladen, wenn der Editor erscheint. Lit-UI und Render-Worker kommen mit ein paar Dutzend Kilobyte obendrauf. In der CI gibt es einen Budget-Check.

Welche Browser werden unterstützt?

Aktuelle Versionen von Chrome, Edge, Safari und Firefox auf Desktop und Mobilgeräten. Der Core nutzt WebAssembly-SIMD, die Untergrenze ist also Chrome 91, Firefox 89 und Safari 16.4. Jeder Commit lässt die Paritäts-Suite in Chromium, WebKit und Firefox laufen, die UI-Suite in Chromium und WebKit. Auf iOS Safari fällt der Download auf das Teilen-Menü zurück.

Kann ich ein eigenes Tool schreiben?

Ja. npm create @sealpixel/plugin legt ein Paket mit Operationen, Reducer, JavaScript- oder Rust-Kernel und Tool-Panel an. Das Test-Kit rendert dein Plugin in Node und drei Browsern und prüft gleiche Hashes. Zwei Beispiel-Plugins liegen im Repository.