Skip to content

Latest commit

 

History

History
373 lines (243 loc) · 30.2 KB

Readme.de-DE.md

File metadata and controls

373 lines (243 loc) · 30.2 KB
Kurzfassung

fount ist eine programmierbare, standardisierte, modulare und anpassbare Laufzeitumgebung für AI-Agenten, die verschiedene Komponenten lädt, um Dienste bereitzustellen.
Für codebezogene Fragen siehe deepwiki.
Der Name fount wird ausschließlich kleingeschrieben—also fount, nicht Fount.

Warum fount?

  • Standardisiertes, reiches, leistungsstarkes Ökosystem sofort nutzbar; kein Rad neu erfinden, keine Debug-Alpträume
  • Agent-Logik anpassen, nicht nur Prompts und UI
  • Andere starke fount-Agenten der Community nutzen und als Referenz verwenden
  • Ideal für den Büroalltag, schneller Report-Export
  • Nahtlose Integration von Charakteren in IDEs, Browser, Terminals, Discord usw.
  • Agent-orientierte Plugins aus der Community, die andere LLM-Chat-Frontends nicht haben
  • API konfigurieren, dann den Standard-Charakter ZL-31 nutzen, um Komponenten-Konfiguration, Erstellung und alle Benutzeraktionen per Dialog zu erledigen—ohne Einarbeitung

Warum nicht fount?

  • Höhere Einarbeitungskosten, Code-Kenntnisse nötig
  • Einige Community-Komponenten können schädlichen Code enthalten; prüfen und auswählen
Was soll ich verwenden?

OpenClaw nutzen, wenn du:

  • Agenten ohne tiefe Anpassung oder Effizienz-Tuning ausprobieren möchtest

ChatGPT oder ähnliche Online-LLM-Chat-Plattformen nutzen, wenn du:

  • Nur chatten möchtest
  • Keine tiefe Anpassung von KI-Charakteren brauchst
  • Mit Cloud-Speicherung ohne Export/Migration einverstanden bist
  • Mit Werbung einverstanden bist

character.ai oder ähnliche Online-LLM-Rollenspiel-Plattformen nutzen, wenn du:

  • Einen LLM-gesteuerten Charakter ohne Agent-Funktionen betreiben möchtest
  • Mit Abo-Kosten einverstanden bist
  • Keine Software konfigurieren möchtest

SillyTavern nutzen, wenn du:

  • Einen Charakter oder eine Funktion brauchst, die STscript oder SillyTavern-Plugins erfordert

⛲fount💪

Ein Geistesblitz, aus Gedanken geboren

fount repo Ask DeepWiki Docker Image Size GitHub repo size Discord CodeFactor Codacy Badge

steve02081504%2Ffount | Trendshift

repo img

Was ist fount?

fount ist eine moderne, erweiterbare Laufzeitumgebung für AI-Agenten.

Wir glauben, dass hocheffiziente Produktivitätswerkzeuge und immersive, emotionale Interaktion sich nicht ausschließen müssen. fount ist eine Brücke: Tagsüber kann es der zuverlässige Helfer sein, der Sie beim Schreiben komplexer Codes oder beim Organisieren von Besprechungsprotokollen unterstützt; nachts kann es der digitale Vertraute sein, der Ihre Emotionen versteht und mit Ihnen mitfühlt.

Nach relative date hingebungsvoller Entwicklung, durch die Leidenschaft von GitHub contributors und mit einer lebendigen Community von number of active users ist fount heute eine ausgereifte, stabile und sich ständig weiterentwickelnde AI-Interaktionsplattform.

Wenn Sie von Grund auf konfigurieren, einrichten und loslegen möchten, können Sie das Community-Tutorial fount-Anleitung für Dummies von Grund auf konsultieren (das Tutorial ist auf Chinesisch, Nicht-Chinesisch-Sprecher können die Übersetzungsfunktion des Browsers nutzen).

Bild

🚀 Effizienz und Engineering: Gemacht für Büroangestellte, Entwickler und Geeks

fount verwandelt Interaktion in Produktivitäts-Assets. Alles funktioniert per Drag-and-Drop, alles ist eine Datei, die Logik wird durch Code angetrieben.

1. Kein Lernen nötig, sofort nutzbar

  • API konfigurieren, dann den Standard-Charakter ZL-31 nutzen, um Komponenten-Konfiguration, Erstellung und alle Benutzeraktionen per Dialog zu erledigen—ohne Einarbeitung. Bild

2. Wissens-Asset-Erstellung und nahtloses Teilen

  • Sofortige Berichtserstellung: Ziehen Sie eine Dialogblase direkt in einen Ordner, um sofort einen unabhängigen HTML-Bericht zu generieren. Ideal für die schnelle Organisation von technischen Dokumenten, Besprechungsprotokollen oder Ideenfragmenten. Bild
  • Workflow-Kapselung und -Verteilung: Ziehen Sie die von Ihnen erstellte Rolle direkt auf den Desktop, um eine teilbare Datei zu erzeugen. Verteilen Sie Ihr Prompt-Engineering und Ihre Workflow-Logik mühelos an Kollegen oder die Community. Bild

3. Echtzeit-Codeausführungsumgebung

Nicht mehr nur Markdown-Hervorhebung. In fount sind die vom Agenten gesendeten Codeblöcke lebendig.

  • Unterstützt Echtzeit-Kompilierung und -Ausführung für verschiedene Sprachen (C/C++/Rust/Python/JS usw.).
  • Direkte Anzeige der stdout-Ausgabe, und sogar der ASM-Disassemblierungsergebnisse für kompilierte Sprachen.
  • Lassen Sie die KI zum Echtzeit-Verifizierer für Ihre Pair-Programming-Sitzungen werden. Bild

4. Entwicklerfreundlich

Die Projektarchitektur von fount wurde unter umfassender Berücksichtigung der Gewohnheiten von Entwicklern konzipiert. Möchten Sie die Architektur des Projekt-Repositorys kennen? Werfen Sie einen Blick auf DeepWiki!

  • Git-gesteuert: Alle Komponenten können über Git verwaltet werden.
  • VSCode-Integration: Die Projektstruktur ist klar. In Verbindung mit den Anweisungen in AGENTS.md können Sie Ihre Agent-Logik direkt in Ihrer bevorzugten IDE entwickeln und debuggen.

🎭 Immersion und Empathie: High-Fidelity-Interaktionserlebnis

Nach Feierabend bietet fount eine Verbindung, die über das Übliche hinausgeht. Wir haben uns von der Steifheit traditioneller Werkzeuge verabschiedet und streben nach einer natürlichen, flüssigen und tiefgründigen "High-Fidelity"-Interaktion.

  • Nahtlose Plauderei, jederzeit und überall Ein auf dem Computer begonnenes Gespräch kann nahtlos auf dem Handy oder Tablet fortgesetzt werden. fount hält Ihre Unterhaltungen synchron, sodass Sie überall eng mit Ihrem Agenten verbunden sind.

  • Ausdrucksstarker, immersiver Chat Durch die Kraft von HTML ermöglicht fount dem Agenten, sich durch Rich Text, Bilder und sogar interaktive Elemente auszudrücken, wodurch jede Unterhaltung lebendig und tiefgründig wird.

  • Ein Fest der Gedanken: Native Gruppenchats Laden Sie mehrere Agenten zu einem Gespräch ein und erleben Sie ihre dynamischen und fesselnden Interaktionen, sei es für ein Brainstorming im Beruf oder die Inszenierung einer Geschichte zwischen den Agenten. Bild

  • Ästhetische, anpassbare Oberfläche Wählen Sie aus über 30 atemberaubenden Themen oder gestalten Sie Ihre eigenen Farben. fount ist Ihre exklusive Leinwand. Bild

  • Überall einsetzbar fount läuft nahtlos auf Windows, macOS, Linux und sogar Android und erfüllt Ihre unterschiedlichen Anforderungen durch direkte Installation oder die Flexibilität von Docker.

  • Fesselnde Integration von AI-Quellen: Umfassen Sie die Unendlichkeit fount bietet eine unvergleichliche Auswahl und Flexibilität bei der Verbindung mit AI-Quellen. Der benutzerdefinierte JavaScript-Code im AI-Quellengenerator ermöglicht es Ihnen, sich mit jeder AI-Quelle zu verbinden – OpenAI, Claude, OpenRouter, NovelAI, Horde, Ooba, Tabby, Mistral... Im Fluss des Codes können Sie komplexe reguläre Ausdrücke entwerfen, umfangreiche API-Bibliotheken aufrufen und Multimedia-Ressourcen einbetten. fount unterstützt auch nativ die Erstellung von API-Pools für intelligentes Request-Routing. Die Kommunikationslogik folgt Ihrer Absicht und wird durch die Kraft des Codes geformt. Bild

Wenn Sie sich im Meer der Agenten verloren fühlen oder nach vergessenen Geschichten suchen, erwartet Sie unsere lebendige und freundliche Community. Es ist ein Hafen für Gleichgesinnte, in dem Entwickler und Kreative ihr Wissen und ihre Kreationen teilen.

Kameradschaft: Jenseits des digitalen Schleiers

fount ist bestrebt, Charaktere in das Gewebe deines Lebens einzuweben und Kameradschaft und Unterstützung anzubieten, die den Bildschirm überwinden.

  • Discord/Telegram-Integration Verbinde deine Charaktere über integrierte Bot-Shells mit Discord- oder Telegram-Communitys und mache sie zu lebendigen Mitgliedern deiner Kreise. Image Image Image

  • Browser-Integration Integrieren Sie Charaktere in Browser-Erweiterungen, sodass sie den Inhalt von Seiten in Ihrem Browser sehen und ändern können, um wirklich "mit KI im Internet zu surfen". Sie können zu Ihrem Charakter sagen: Hey XX, hilf mir, die Farbe dieser Seite zu ändern und etwas Dekoration hinzuzufügen. Image

  • IDE-Integration Integrieren Sie Charaktere in IDEs wie JetBrains, neovim, Zed usw., damit sie kontextbezogene Unterstützung und Vorschläge beim Schreiben von Code bieten, genau wie Cursor Agent oder GitHub Copilot. Image

  • Terminal-Gelassenheit (mit fount-pwsh) Wenn ein Terminalbefehl ins Stocken gerät, lass deinen Charakter ein leises Wort der Führung anbieten und die Einsamkeit der digitalen Welt lindern. Image

  • Grenzenlose Shell-Erweiterungen Mit ein wenig Programmierkenntnissen kannst du deine eigenen fount-Shells erstellen und die Reichweite deiner Charaktere in jeden erdenklichen Winkel erweitern.

Schöpfung: Jenseits der Grenzen von Prompts

Für den Schöpfer bietet fount einen klareren Weg, um deine KI-Charaktere zum Leben zu erwecken.

  • Revolutionäre KI-gestützte Schöpfung Beschreibe deinen gewünschten Charakter in einem einzigen Satz, und unser intelligenter KI-Assistent erstellt eine vollständig realisierte Persona. Dies vereinfacht die anfängliche Einrichtung und ermöglicht es dir, dich auf die Verfeinerung und Interaktion mit deiner Kreation zu konzentrieren.

  • Die Magie des Codes, einfacher als du denkst In fount ist Code eine Form moderner Magie. Mit der sanften Führung unserer Community und der aufschlussreichen Hilfe von KI ist das Erlernen überraschend einfach. Du wirst feststellen, dass das Definieren von Charakterlogik mit Code eine intuitive und wartbare Weise sein kann, um Charaktere zu erschaffen, deren Antworten aus deiner eigenen Logik gewoben sind.

  • Beginne mit fertiger Magie: Eine Schatzkammer von Vorlagen Die Community von fount bietet eine Fülle von vorgefertigten Charakter- und Persona-Vorlagen. Sie dienen als „lebende Blaupausen“, die einfach anzupassen sind und einen fantastischen Ausgangspunkt bieten.

  • Eingebettete Ressourcen Webe Bilder, Audio und andere Ressourcen direkt in deine Charaktere ein und mache ihre Präsenz umso greifbarer. Image

  • Kontinuierliche Integration Nutze fount-charCI, um deine Charakterentwicklung abzusichern. Es führt bei jedem Commit automatisch Tests aus und meldet Probleme in Echtzeit. Image Image

  • Legacy-Kompatibilität fount umarmt die Vergangenheit und bietet Kompatibilitätsmodule zum Ausführen von SillyTavern- und Risu-Charakterkarten (obwohl die Migration bestehender Charaktere nicht unterstützt wird).

Architektur: Das Fundament der Innovation

fount basiert auf einer robusten und skalierbaren Architektur. Das Backend nutzt die Leistung und Geschwindigkeit von Deno, mit Express für effizientes Routing. Das Frontend ist mit HTML, CSS und JavaScript für eine intuitive und ansprechende Benutzeroberfläche gestaltet.

Erweiterung: Ein Gewebe, gewebt aus vielfältigen Fäden

In der Welt von fount regiert die Modularität. Ein reichhaltiges Ökosystem von Komponenten verwebt sich, um das Gewebe deiner Erfahrung zu erschaffen. All diese können von den Nutzern mühelos installiert, erweitert und angepasst werden.

  • chars (Charaktere): Das Herzstück von fount, wo Persönlichkeiten geboren werden.
  • worlds (Welten): Weit mehr als bloße Lorebücher. Sie sind die stillen Architekten der Realität, die Wissen hinzufügen, Entscheidungen beeinflussen und sogar den Chatverlauf manipulieren können.
  • personas (Benutzer-Personas): Mehr als nur Benutzerprofile. Personas besitzen die Macht, deine Worte zu verzerren und sogar die Kontrolle darüber zu übernehmen, was ein wirklich immersives Rollenspiel ermöglicht.
  • shells (Interaktionsschnittstellen): Die Tore zur Seele von fount, die die Reichweite von Charakteren über die Benutzeroberfläche hinaus erweitern.
  • ImportHandlers (Import-Handler): Die einladenden Hände von fount, die die Kluft zwischen verschiedenen Charakterformaten überbrücken.
  • AIsources (KI-Quellen): Die rohe Kraft, die den Geist deiner Charaktere befeuert.
  • AIsourceGenerators (KI-Quellengeneratoren): Die Alchemisten von fount, die Vorlagen und Logik über JavaScript bereitstellen, um Verbindungen zu jeder erdenklichen KI-Quelle zu schmieden.

Image

Installation & Deinstallation: Eine elegante Begegnung und ein Abschied

Installation: fount in deine Welt einweben – Mühelos

Tip

Wenn Sie von Grund auf konfigurieren, einrichten und loslegen möchten, können Sie das Community-Tutorial fount-Anleitung für Dummies von Grund auf konsultieren (das Tutorial ist auf Chinesisch, Nicht-Chinesisch-Sprecher können die Übersetzungsfunktion des Browsers nutzen).

Beginne deine Reise mit fount, einer stabilen und zuverlässigen Plattform. Ein paar einfache Klicks oder Befehle, und die Welt von fount entfaltet sich.

Caution

In der Welt von fount können Charaktere frei JavaScript-Befehle ausführen, was ihnen beträchtliche Macht verleiht. Wähle daher die Charaktere, denen du vertraust, mit derselben Sorgfalt wie im echten Leben, um die Sicherheit deiner lokalen Dateien zu gewährleisten.

Linux/macOS/Android: Das Flüstern der Shell – Ein Befehl, und die Reise beginnt

# Definiere bei Bedarf die Umgebungsvariable $FOUNT_DIR, um das fount-Verzeichnis anzugeben
INSTALLED_PACKAGES="${FOUNT_AUTO_INSTALLED_PACKAGES:-}"
install_package() { _command_name="$1"; _package_list=${2:-$_command_name}; _has_sudo=""; _installed_pkg_name="" ; if command -v "$_command_name" >/dev/null 2>&1; then return 0; fi; if [ "$(id -u)" -ne 0 ] && command -v sudo >/dev/null 2>&1; then _has_sudo="sudo"; fi; for _package in $_package_list; do if command -v apt-get >/dev/null 2>&1; then $_has_sudo apt-get update -y; $_has_sudo apt-get install -y "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v pacman >/dev/null 2>&1; then $_has_sudo pacman -Syy --noconfirm; $_has_sudo pacman -S --needed --noconfirm "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v dnf >/dev/null 2>&1; then $_has_sudo dnf install -y "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v yum >/dev/null 2>&1; then $_has_sudo yum install -y "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v zypper >/dev/null 2>&1; then $_has_sudo zypper install -y --no-confirm "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v apk >/dev/null 2>&1; then if [ "$(id -u)" -eq 0 ]; then apk add --update "$_package"; else $_has_sudo apk add --update "$_package"; fi; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v brew >/dev/null 2>&1; then if ! brew list --formula "$_package"; then brew install "$_package"; fi; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v pkg >/dev/null 2>&1; then pkg install -y "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v snap >/dev/null 2>&1; then $_has_sudo snap install "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; done; if command -v "$_command_name" >/dev/null 2>&1; then case ";$FOUNT_AUTO_INSTALLED_PACKAGES;" in *";$_installed_pkg_name;"*) ;; *) if [ -z "$FOUNT_AUTO_INSTALLED_PACKAGES" ]; then FOUNT_AUTO_INSTALLED_PACKAGES="$_installed_pkg_name"; else FOUNT_AUTO_INSTALLED_PACKAGES="$FOUNT_AUTO_INSTALLED_PACKAGES;$_installed_pkg_name"; fi; ;; esac; return 0; else echo "Error: Failed to install '$_command_name' from any source." >&2; return 1; fi; }
install_package "bash" "bash gnu-bash"; install_package "curl"
export FOUNT_AUTO_INSTALLED_PACKAGES="$INSTALLED_PACKAGES"
curl -fsSL https://raw.githubusercontent.com/steve02081504/fount/refs/heads/master/src/runner/main.sh | bash
. "$HOME/.profile"

Solltest du eine Pause einlegen wollen, um deine Gedanken vor dem großen Abenteuer zu sammeln (ein Probelauf):

INSTALLED_PACKAGES="${FOUNT_AUTO_INSTALLED_PACKAGES:-}"
install_package() { _command_name="$1"; _package_list=${2:-$_command_name}; _has_sudo=""; _installed_pkg_name="" ; if command -v "$_command_name" >/dev/null 2>&1; then return 0; fi; if [ "$(id -u)" -ne 0 ] && command -v sudo >/dev/null 2>&1; then _has_sudo="sudo"; fi; for _package in $_package_list; do if command -v apt-get >/dev/null 2>&1; then $_has_sudo apt-get update -y; $_has_sudo apt-get install -y "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v pacman >/dev/null 2>&1; then $_has_sudo pacman -Syy --noconfirm; $_has_sudo pacman -S --needed --noconfirm "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v dnf >/dev/null 2>&1; then $_has_sudo dnf install -y "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v yum >/dev/null 2>&1; then $_has_sudo yum install -y "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v zypper >/dev/null 2>&1; then $_has_sudo zypper install -y --no-confirm "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v apk >/dev/null 2>&1; then if [ "$(id -u)" -eq 0 ]; then apk add --update "$_package"; else $_has_sudo apk add --update "$_package"; fi; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v brew >/dev/null 2>&1; then if ! brew list --formula "$_package"; then brew install "$_package"; fi; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v pkg >/dev/null 2>&1; then pkg install -y "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; if command -v snap >/dev/null 2>&1; then $_has_sudo snap install "$_package"; if command -v "$_command_name" >/dev/null 2>&1; then _installed_pkg_name="$_package"; break; fi; fi; done; if command -v "$_command_name" >/dev/null 2>&1; then case ";$FOUNT_AUTO_INSTALLED_PACKAGES;" in *";$_installed_pkg_name;"*) ;; *) if [ -z "$FOUNT_AUTO_INSTALLED_PACKAGES" ]; then FOUNT_AUTO_INSTALLED_PACKAGES="$_installed_pkg_name"; else FOUNT_AUTO_INSTALLED_PACKAGES="$FOUNT_AUTO_INSTALLED_PACKAGES;$_installed_pkg_name"; fi; ;; esac; return 0; else echo "Error: Failed to install '$_command_name' from any source." >&2; return 1; fi; }
install_package "bash" "bash gnu-bash"; install_package "curl"
export FOUNT_AUTO_INSTALLED_PACKAGES="$INSTALLED_PACKAGES"
curl -fsSL https://raw.githubusercontent.com/steve02081504/fount/refs/heads/master/src/runner/main.sh | bash -s init
. "$HOME/.profile"

Windows: Eine Auswahl von Pfaden – Der Weg der Einfachheit

  • Direkt und unkompliziert (Empfohlen): Lade die exe-Datei von den Releases herunter und führe sie aus.

  • Die Macht von PowerShell:

    # Definiere bei Bedarf die Umgebungsvariable $env:FOUNT_DIR, um das fount-Verzeichnis anzugeben
irm https://raw.githubusercontent.com/steve02081504/fount/refs/heads/master/src/runner/main.ps1 | iex

    Für einen Probelauf:

    $scriptContent = Invoke-RestMethod https://raw.githubusercontent.com/steve02081504/fount/refs/heads/master/src/runner/main.ps1
Invoke-Expression "function fountInstaller { $scriptContent }"
fountInstaller init

Git-Installation: Für diejenigen, die einen Hauch von Magie bevorzugen

Wenn du Git bereits installiert hast, ist die Annahme von fount so einfach wie das Ausführen eines Skripts.

  • Für Windows: Öffne deine Eingabeaufforderung oder PowerShell und doppelklicke einfach auf run.bat.
  • Für Linux/macOS/Android: Öffne dein Terminal und führe ./run.sh aus.

Docker: Den Container umarmen

docker pull ghcr.io/steve02081504/fount

Deinstallation: Ein graziöser Abschied

fount remove

Begegnest du einem Schatten? Fürchte dich nicht

Solltest du auf deiner Reise auf Schwierigkeiten stoßen, wende dich bitte an uns. Wir sind hier, um zu helfen und verpflichten uns, die meisten Probleme innerhalb von 10 Minuten bis 24 Stunden zu lösen.

  • GitHub Issues: Melde alle Fehler oder schlage neue Funktionen über GitHub Issues vor.
  • Discord-Community: Tritt unserer lebendigen Discord-Community bei, um Echtzeit-Support und Diskussionen zu erhalten.

Deine Stimme wird gehört werden. Starte fount einfach neu, und die Schatten werden sich auflösen.

Embleme & Links: Lass Kreationen erstrahlen, lass die Welt sie erreichen

Die Welt von fount ist mehr als Worte und Code; sie ist ein Fest für die Augen und eine Einladung zur Verbindung. Wir haben exquisite Embleme und praktische Links vorbereitet, um deine fount-Komponenten erstrahlen zu lassen und es anderen zu ermöglichen, deine Meisterwerke leicht zu entdecken.

fount-Embleme: Das Siegel des Ruhms

Du kannst dieses Emblem stolz in deinem Repository oder überall dort präsentieren, wo du deine Arbeit zeigen möchtest. Die SVG-Dateien des fount-Logos findest du hier.

[![fount repo](https://steve02081504.github.io/fount/badges/fount_repo.svg)](https://github.com/topics/fount-repo)

fount repo

[![fount character](https://steve02081504.github.io/fount/badges/fount_character.svg)](https://github.com/topics/fount-character)

fount character

Farbformat Code
HEX #0e3c5c
RGB rgb(14, 60, 92)
HSL hsl(205, 74%, 21%)

Du kannst auch den Badge-Adder verwenden, um jedes shields.io-Badge mit dem fount-Logo zu versehen.

Automatische Installationslinks: Magie auf Knopfdruck

Stell dir vor, andere installieren deine Kreationen mit einem einzigen Klick in ihre fount-Welt. Kombiniere einfach den ZIP- oder Git-Repository-Link deiner Komponente mit dem Protokolllink von fount.

https://steve02081504.github.io/fount/protocol?url=fount://run/shells/install/install; + Dein_Komponenten_Link

Empfohlene Browser: Für eine perfekte Begegnung

Das Frontend von fount ist aus modernen Web-Technologien gewoben, aber nicht alle Browser schwingen perfekt mit seiner Seele mit. Für das heiterste und flüssigste Erlebnis empfehlen wir Weggefährten, die im Einklang mit dem Rhythmus von fount sind:

  • Google Chrome / Microsoft Edge / Opera: Sie bewegen sich im Gleichklang mit founts Geist und bieten die beste Leistung und Kompatibilität für eine Interaktion, die so geschmeidig wie Poesie ist.

Andere Browser jedoch gehen einen anderen Weg, und ihre Begegnung mit fount kann eine leichte Dissonanz aufweisen:

  • Mozilla Firefox: Er gleicht einem störrischen Wanderer, der neue Technologien oft nur zögerlich umarmt und manchmal beschließt, ewig in der Vergangenheit zu verweilen. Doch diese Beharrlichkeit fordert ihren Tribut:

    • Ohne Unterstützung für speculationrules wird jeder Kaltstart und jede Protokollverarbeitung von fount 1-2 Sekunden langsamer sein als nötig – Momente, die dir heimlich gestohlen werden.
    • Das Fehlen der Unterstützung für CSS anchor-Positionierung hinterlässt einen Schleier der Unvollkommenheit auf einigen Seiten und trübt eine Stimmung, die rein sein sollte.
    • Das Fehlen der Unterstützung für blocking="render" kann dazu führen, dass fount-Seiten beim Laden flackern und deine Augen verletzen.
    • Laut Backend-Fehlerberichten fallen fount-Seiten nur in der Welt von Firefox manchmal in mysteriöse Fehler oder erscheinen seltsam – wenn das passiert, versuche, die Seite neu zu laden; vielleicht vertreibt das den Nebel.

  • Apple Safari: Seine Unterstützung für „neue“ (mehrere Jahre alte) Web-Standards mag einen Hauch besser sein als die von Firefox, aber nicht viel.

    • Auch hier fehlt die Unterstützung für speculationrules, was bedeutet, dass der Start von fount immer noch eine leichte Verzögerung aufweisen wird, die deine kostbaren Momente verschwendet.

  • Brave: Obwohl auf Chromium basierend, kann sein gewaltiger Schutzschild der Privatsphäre manchmal unbeabsichtigt etwas von founts Licht verdecken und die normale Funktion bestimmter Features beeinträchtigen.

Erlebe das Wachstum: founts Sternen-Historie

Star History Chart

Mitwirkende

Contributors

Zusammenfassend: Die Hand des Kunsthandwerkers

Jenseits des Flüsterns der KI bietet fount eine tiefere Verbindung – die Hand des Kunsthandwerkers. Innerhalb unserer Community findest du eine Fülle von vorgefertigten Charakter- und Persona-Vorlagen, jede ein sorgfältig geformtes Fundament, das auf deine einzigartige Vision wartet, um von ihr erweckt zu werden.

fount ermöglicht es dir, KI-Charaktere auf eine Weise zu erschaffen und mit ihnen zu interagieren, die sich natürlich, immersiv und zutiefst persönlich anfühlt. Egal, ob du ein erfahrener Schöpfer bist oder gerade erst deine Reise beginnst, fount heißt dich willkommen.

Tritt unserer einladenden Community bei und entdecke die Magie, deiner Fantasie Leben einzuhauchen, unterstützt von einer ausgereiften Plattform und einem engagierten Team.