# GetCat

> Un client HTTP natif et multiplateforme, conçu avec Rust + GPUI

Un client HTTP libre et open source pour macOS, Windows et Linux. Conçu avec Rust et GPUI : une fenêtre native rendue par le GPU, pas Electron. Aucun compte, rien n'est envoyé en ligne, et plusieurs centaines de Mo de réponse ne figent jamais l'interface.

Licence: Apache-2.0 · Plateformes: macOS, Windows, Linux · Taille du téléchargement: 16 MB

## Sections

- [Fonctionnalités](https://getcat.io/fr/#features)
- [Requêtes](https://getcat.io/fr/#request)
- [Réponses](https://getcat.io/fr/#response)
- [Modèles IA](https://getcat.io/fr/#ai)
- [Espace de travail](https://getcat.io/fr/#workspace)
- [Télécharger](https://getcat.io/fr/#download)
- [Configuration](https://getcat.io/fr/#requirements)
- [Questions fréquentes](https://getcat.io/fr/#faq)

## Conçu pour se faire oublier

Tout ce qui suit correspond à ce que GetCat fait aujourd'hui — aucune entrée de feuille de route déguisée en fonctionnalité.

### Natif et rapide

Une fenêtre native rendue par le GPU — ni Electron, ni Tauri, ni WebView. La même interface sur macOS, Linux et Windows, pour un téléchargement d'environ 16 Mo.

### Les grosses réponses restent fluides

Réception en flux, progression en direct, annulation à tout moment. Le fil principal ne fait jamais de travail en O(n) : plusieurs centaines de Mo de JSON ne bloquent pas la fenêtre.

### Construction complète des requêtes

Sept méthodes, des tableaux Path / Query / en-têtes avec colonne de description, et tous les types de corps, du JSON brut à l'envoi de fichiers en flux.

### Vos données vous appartiennent

Pas d'historique, aucune réponse stockée, rien d'envoyé nulle part. Les requêtes enregistrées et les réglages sont des fichiers JSON formatés, éditables à la main et versionnables avec Git.

### Enregistré au fil de la frappe

Le brouillon de chaque onglet est écrit sur disque et restauré au redémarrage. L'ordre des onglets, le sens de la division et le thème sont également mémorisés.

### Suit votre système

Le thème et la langue suivent le système, ou peuvent être fixés. La barre de titre est dessinée par l'application, donc les trois plateformes se ressemblent. Chaque contrôle porte un nom accessible et fonctionne avec un lecteur d'écran.

L'interface de l'application est disponible en English et 简体中文.

## Construisez la requête, puis emportez le code

Tout ce qu'il faut pour façonner une requête, plus un export en un clic qui correspond exactement à ce que GetCat envoie sur le réseau.

### Sept méthodes

`GET` · `POST` · `PUT` · `PATCH` · `DELETE` · `HEAD` · `OPTIONS`

Écrivez `{name}` n'importe où dans l'URL : le paramètre apparaît automatiquement dans le tableau Path.

### Corps et tableaux de paramètres

| Élément | Détail |
| --- | --- |
| `Aucun corps` | Pour GET, HEAD et OPTIONS. |
| `JSON / Texte / XML brut` | Coloration syntaxique via tree-sitter, avec un bouton de reformatage. |
| `x-www-form-urlencoded` | Paires clé-valeur, l'encodage est pris en charge. |
| `form-data` | Champs texte et champs fichier côte à côte. Les fichiers sont envoyés en flux avec une longueur connue et ne passent jamais en mémoire. |
| `binary` | Un fichier entier comme corps, envoyé de la même façon. |
| Paramètres de chemin | Remplis à partir des marqueurs `{name}` présents dans l'URL. |
| Query | Ajoutés à l'URL, avec activation ligne par ligne. |
| En-têtes | Plus un jeu global d'en-têtes par défaut, désactivable ligne par ligne. |

### Générer le code

cURL, cURL pour Windows, ou Python requests — copiés en un clic. Le générateur réutilise la logique d'assemblage qui envoie réellement la requête : le code que vous copiez est la requête que GetCat aurait faite.

#### cURL

```bash
curl -X POST 'https://api.anthropic.com/v1/messages' \
  -H 'x-api-key: YOUR_API_KEY' \
  -H 'anthropic-version: 2023-06-01' \
  -H 'Content-Type: application/json' \
  -d '{"model":"claude-opus-5","max_tokens":1024,"messages":[{"role":"user","content":"Hello"}]}'
```

#### cURL (Windows)

```bash
curl -X POST "https://api.anthropic.com/v1/messages" ^
  -H "x-api-key: YOUR_API_KEY" ^
  -H "anthropic-version: 2023-06-01" ^
  -H "Content-Type: application/json" ^
  -d "{\"model\":\"claude-opus-5\",\"max_tokens\":1024}"
```

#### Python (requests)

```python
import requests

url = "https://api.anthropic.com/v1/messages"

payload = "{\"model\":\"claude-opus-5\",\"max_tokens\":1024,\"messages\":[{\"role\":\"user\",\"content\":\"Hello\"}]}"
headers = {
    "x-api-key": "YOUR_API_KEY",
    "anthropic-version": "2023-06-01",
    "Content-Type": "application/json"
}

response = requests.request("POST", url, data=payload, headers=headers)

print(response.text)
```

Il omet volontairement les options de TLS, de redirection et de délai d'attente : ce sont des réglages de GetCat, pas des éléments de la requête.

## Des réponses qui ne figent jamais la fenêtre

L'affichage dépend de la taille de la réponse — le fil principal ne se voit jamais confier un travail en O(n).

### Trois paliers selon la taille

| Palier | Quand | Affichage |
| --- | --- | --- |
| Éditeur coloré | jusqu'à 5 Mo et 200,000 lignes | Coloration complète, numéros de ligne, repliage, recherche dans la réponse. |
| Virtualisé par ligne | jusqu'à 64 Mo | Texte brut rendu ligne par ligne : seul ce qui tient à l'écran est mis en page. |
| Déporté sur disque | au-delà de 64 Mo | Écrit dans un fichier temporaire. Les 1 premiers Mio sont prévisualisés avec un résumé, plus l'enregistrement et l'ouverture en un clic. |

**Pendant le téléchargement** — Compteur d'octets en regard du total, rafraîchi toutes les 33 ms environ, et un bouton d'annulation actif à tout moment.

### Examen du certificat

À côté de Body et En-têtes se trouve un onglet Certificat : GetCat analyse hors ligne le certificat feuille du serveur et affiche ce qu'il y a trouvé.

Sujet · Émetteur · Valide à partir du · Expire le · Autres noms du sujet (SAN) · Numéro de série · Algorithme de signature · Empreinte SHA-256

**Il vous avertit dans quatre cas**

- Déjà expiré
- Pas encore valide — vérifiez l'horloge système
- Le nom d'hôte ne correspond pas au certificat
- Auto-signé, sans chaîne de confiance

La vérification TLS est désactivée par défaut afin de pouvoir interroger sans cérémonie un service local à certificat auto-signé. La requête part quand même, et GetCat continue d'analyser le certificat hors ligne et de signaler les quatre cas ci-dessus. Activez la vérification dans les réglages et un certificat invalide interrompt la poignée de main.

## Modèles d'API IA intégrés — corps multimodaux OpenAI et Anthropic comparés

Un clic ouvre un onglet avec l'URL, l'en-tête d'authentification et le corps déjà remplis. L'intérêt réel est la comparaison ci-dessous : ces trois API ne s'accordent sur rien.

### Six modèles

OpenAI Chat Completions, OpenAI Responses et Anthropic Messages, chacun en version texte seul et en version avec image.

Remplacez YOUR_API_KEY avant d'envoyer — GetCat n'a ni variables ni environnements.

### La même requête avec image, de trois façons

#### OpenAI · Chat Completions

`POST https://api.openai.com/v1/chat/completions`

```json
{
  "model": "gpt-5.6",
  "messages": [
    {
      "role": "user",
      "content": [
        { "type": "text", "text": "What is in this image?" },
        {
          "type": "image_url",
          "image_url": {
            "url": "https://example.com/cat.jpg",
            "detail": "auto"
          }
        }
      ]
    }
  ],
  "max_completion_tokens": 1024
}
```

Le bloc image s'appelle image_url, et image_url est un objet contenant url et detail. Le plafond de jetons est max_completion_tokens, pas max_tokens.

#### OpenAI · Responses

`POST https://api.openai.com/v1/responses`

```json
{
  "model": "gpt-5.6",
  "input": [
    {
      "role": "user",
      "content": [
        { "type": "input_text", "text": "What is in this image?" },
        {
          "type": "input_image",
          "image_url": "https://example.com/cat.jpg"
        }
      ]
    }
  ],
  "max_output_tokens": 1024
}
```

Responses renomme les blocs en input_text et input_image, et ici image_url est une simple chaîne plutôt qu'un objet. Le plafond est max_output_tokens.

#### Anthropic · Messages

`POST https://api.anthropic.com/v1/messages`

```json
{
  "model": "claude-opus-5",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "image",
          "source": {
            "type": "url",
            "url": "https://example.com/cat.jpg"
          }
        },
        { "type": "text", "text": "What is in this image?" }
      ]
    }
  ]
}
```

Anthropic utilise image accompagné d'un objet source. max_tokens est obligatoire, et le bloc image est placé avant le bloc texte, comme le recommande leur documentation.

## Votre espace de travail, en fichiers ordinaires

Pas de base de données, pas de cloud, pas de compte. Tout ce que GetCat retient est un fichier JSON que vous pouvez ouvrir, modifier et committer.

### Ce qui est écrit

| Élément | Détail |
| --- | --- |
| `workspace.json` | Ordre des onglets, état de la barre latérale, sens de la division, thème. |
| `requests/<ulid>.json` | Une requête enregistrée par fichier. |
| `drafts/<tab-id>.json` | Un brouillon par onglet, restauré au redémarrage. |
| `settings.json` | Réglages de l'application. |

### Où cela se trouve

| Plateforme | Répertoire |
| --- | --- |
| macOS | `~/Library/Application Support/GetCat/` |
| Linux | `$XDG_DATA_HOME/getcat/` |
| Windows | `%APPDATA%\GetCat\data\` |

Les écritures sont atomiques : un fichier temporaire est mis en place par échange, donc un plantage ne laisse jamais un demi-fichier. Un fichier illisible est renommé en `.corrupt-<heure>` puis ignoré. Les en-têtes comme `Authorization` sont enregistrés en clair, comme dans les bases locales de Postman et d'Insomnia, avec des permissions 0600 sur Unix.

### Raccourcis clavier

| Action | macOS | Windows / Linux |
| --- | --- | --- |
| Envoyer | `⌘ Enter` | `Ctrl Enter` |
| Nouvel onglet | `⌘ T` | `Ctrl T` |
| Fermer l'onglet | `⌘ W` | `Ctrl W` |
| Barre latérale | `⌘ B` | `Ctrl B` |
| Enregistrer la requête | `⌘ S` | `Ctrl S` |
| Rechercher dans la réponse | `⌘ F` | `Ctrl F` |
| Réglages | `⌘ ,` | `Ctrl ,` |

### Ce que GetCat ne fait délibérément pas

Cette liste est là pour que vous le sachiez avant de télécharger, et pour que personne n'ait à deviner par analogie avec d'autres outils :

historique des requêtes · variables d'environnement et substitution · scripts et assertions de test · panneau d'authentification dédié · gestion des cookies · arborescence de dossiers · GraphQL, WebSocket et gRPC · synchronisation d'équipe et comptes cloud

## Télécharger

Toutes les versions sont sur GitHub Releases. Les liens pointent toujours vers la plus récente.

| Plateforme | Élément | Fichier |
| --- | --- | --- |
| macOS | Apple Silicon | `GetCat-macos-arm64.dmg` |
| macOS | Intel | `GetCat-macos-x64.dmg` |
| Windows | x64 · installeur | `GetCat-windows-x64.msi` |
| Windows | x64 · portable | `GetCat-windows-x64.exe` |
| Linux | x64 | `GetCat-linux-x64.tar.gz` |

### Installation

- **macOS** — Signé et notarié — glissez-le dans Applications.
- **Windows** — Le MSI s'installe pour l'utilisateur courant, sans droits administrateur, et apparaît dans le menu Démarrer. L'exe portable fonctionne depuis n'importe où et n'écrit rien dans le registre.
- **Linux** — Décompressez et placez le binaire dans votre PATH. Un fichier .desktop suffit à l'ajouter au lanceur — les commandes sont ci-dessous.

#### Installation sous Linux

```bash
tar -xzf GetCat-linux-x64.tar.gz
install -Dm755 getcat ~/.local/bin/getcat
mkdir -p ~/.local/share/applications
cat > ~/.local/share/applications/getcat.desktop <<EOF
[Desktop Entry]
Type=Application
Name=GetCat
Exec=$HOME/.local/bin/getcat
Categories=Development;
EOF
```

Les binaires Windows ne sont pas encore signés : SmartScreen bloquera le premier lancement. Choisissez « Informations complémentaires », puis « Exécuter quand même ».

### Mises à jour

GetCat interroge GitHub Releases une seule fois, cinq secondes après le lancement, et ne télécharge jamais rien de lui-même. Lorsque vous choisissez de mettre à jour, le téléchargement est vérifié par SHA-256 et par une signature minisign avant installation.

## Configuration requise

GetCat dessine avec le GPU : la pile graphique compte davantage que le processeur.

### macOS

Apple Silicon ou Intel. L'image disque est signée et notariée.

### Windows

Windows 10 version 1803 (mise à jour d'avril 2018) ou plus récent, ou Windows 11. Le rendu passe par Direct3D 11 au feature level 10.1 — en pratique, tout GPU à partir de 2010. DirectX 12 n'est pas requis.

### Linux

Les distributions de bureau courantes depuis 2022 : Ubuntu 22.04+, Debian 12+, Fedora 36+, Linux Mint 21+, openSUSE Leap 15.6+, ainsi que les versions en évolution continue comme Arch. Le plancher est glibc 2.35 : Ubuntu 20.04, Debian 11 et les dérivés de RHEL 9 ne peuvent pas l'exécuter.

### Linux : une fenêtre noire signifie Vulkan

L'interface est rendue via Vulkan. Si la fenêtre reste noire, vérifiez d'abord le pilote avec `vulkaninfo --summary`, puis installez le paquet correspondant à votre GPU :

| GPU | Paquet |
| --- | --- |
| Mesa | `mesa-vulkan-drivers` |
| Intel | `vulkan-intel` |
| AMD | `vulkan-radeon` |
| NVIDIA | `nvidia-driver` |

`vulkaninfo --summary` — Nouveau ne prend pas en charge Vulkan : les cartes NVIDIA nécessitent le pilote propriétaire. Dans une machine virtuelle, le rendu bascule sur la rastérisation logicielle lavapipe, qui fonctionne mais reste lente.

## Questions fréquentes

### En quoi est-ce différent de Postman ?

GetCat est un sous-ensemble assumé. Ni compte, ni synchronisation cloud, ni collections, ni variables d'environnement, ni scripts. En échange, vous obtenez une application native de 16 Mo qui démarre instantanément, garde chaque octet sur votre machine et encaisse de très grosses réponses sans caler. Si vous avez besoin de collaboration d'équipe ou de suites de tests, Postman et Insomnia restent les bons outils.

### Pourquoi pas Electron ou Tauri ?

GetCat est écrit en Rust au-dessus de GPUI, le cadre d'interface qui fait tourner l'éditeur Zed. La fenêtre est dessinée par le GPU plutôt que par un moteur de navigateur : c'est ce qui maintient le téléchargement autour de 16 Mo et permet au panneau de réponse de rester réactif pendant que des centaines de mégaoctets arrivent. Le réseau tourne sur un runtime Tokio et les résultats reviennent au fil d'interface par un canal, de sorte que le fil principal ne fait jamais de travail en O(n).

### Où sont stockées mes requêtes et mes clés d'API ? Sont-elles envoyées quelque part ?

Rien n'est envoyé : aucune télémétrie, aucun compte, aucune synchronisation. Les requêtes enregistrées, les brouillons et les réglages sont des fichiers JSON formatés dans le répertoire de données de votre plateforme, que vous pouvez éditer à la main ou suivre dans Git. Les valeurs d'en-tête comme Authorization sont stockées en clair, exactement comme le font les bases locales de Postman et d'Insomnia, avec des permissions 0600 sur Unix.

### Pourquoi la vérification TLS est-elle désactivée par défaut ?

Pour qu'interroger un service local à certificat auto-signé fonctionne immédiatement, ce qui est le cas courant en développement. La requête part quand même, et GetCat analyse toujours le certificat du serveur hors ligne pour vous avertir s'il est expiré, pas encore valide, émis pour un autre nom d'hôte, ou auto-signé sans chaîne de confiance. Activer la vérification dans les réglages rétablit le comportement strict : un certificat invalide interrompt la poignée de main.

### Les variables d'environnement, les assertions de test ou le travail en équipe sont-ils gérés ?

Non, et rien de tout cela n'est prévu sur la ligne actuelle. GetCat n'a pas de substitution de variables, pas de script avant ou après la requête, pas d'exécuteur d'assertions, pas de gestion des cookies, pas d'arborescence de dossiers et pas d'espaces partagés. Les modèles couvrent le cas des requêtes répétitives ; le reste est délibérément laissé de côté pour que l'application reste petite et prévisible.

### La fenêtre est noire sous Linux. Que faire ?

L'interface est rendue via Vulkan, et une fenêtre noire signifie presque toujours que le pilote Vulkan manque. Lancez `vulkaninfo --summary` pour le confirmer, puis installez mesa-vulkan-drivers, vulkan-intel ou vulkan-radeon selon votre GPU. Les cartes NVIDIA nécessitent le pilote propriétaire — nouveau ne gère pas Vulkan. Dans une machine virtuelle, le rendu bascule sur lavapipe en logiciel.

### GraphQL, WebSocket ou gRPC sont-ils pris en charge ?

Non. GetCat ne parle que HTTP. Vous pouvez bien sûr envoyer une requête GraphQL en POST sous forme de corps JSON, mais il n'y a ni introspection de schéma, ni abonnements, ni interface spécifique à ces protocoles.

### Combien cela coûte-t-il, et quelle est la licence ?

C'est gratuit et open source, sous licence Apache-2.0. Aucune formule payante, aucun compte, rien à créer. Le code source, le suivi des tickets et chaque binaire sont sur GitHub.

## Liens

- [Site officiel](https://getcat.io/fr/)
- [GitHub](https://github.com/finch-xu/GetCat): code source et issues
- [Releases](https://github.com/finch-xu/GetCat/releases): toutes les versions et installeurs
- [DeepWiki](https://deepwiki.com/finch-xu/GetCat): documentation de code générée
