How to use the Clash series network proxy for self-built single-node connection

## What is Clash?

**Clash** is an open-source, multi-platform proxy client developed in the Go language. Unlike traditional single-protocol proxy tools, its core positioning is as a **Rule-based Tunnel**.

Simply put, Clash is like an intelligent traffic command center:

- It supports multiple protocols (Shadowsocks, V2Ray, Trojan, Snell, ShadowsocksR, etc.).
- It can automatically determine which traffic should go direct and which should go through a proxy based on rules you set.
- It features powerful proxy group functionality, supporting automatic speed testing, failover, and load balancing.

## What are the mainstream Clash series tools currently?

Since the developers of the original Clash core and its GUI interfaces (like Clash for Windows) have mostly ceased maintenance, the community has primarily shifted to the more powerful **Mihomo core (also known as Clash Meta)**.

Here are the most popular tools for each platform currently:

| **Platform**                | **Recommended Tool (with GitHub Link)**                      | **Characteristics**                                          |
| --------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
| **Windows / macOS / Linux** | **[Clash Verge (Rev)](https://github.com/clash-verge-rev/clash-verge-rev)** | **The current top choice for desktop**. Modern interface, deeply integrated with the Mihomo core. |
| **Android**                 | **[Clash Meta for Android](https://github.com/MetaCubeX/ClashMetaForAndroid)** | Open-source and feature-rich, supports various new protocols (e.g., Reality, Hysteria2). |
| **iOS**                     | **[Stash](https://www.google.com/search?q=https://github.com/StashProject/Stash)** | **Paid, closed-source software**. While the code is not open-source, the official team maintains documentation and a rules repository. |
| **Soft Router (OpenWrt)**   | **[OpenClash](https://github.com/vernesong/OpenClash)**      | The most powerful Clash plugin for soft routers, highly customizable configuration. |
| **Core Kernel**             | **[Mihomo (Meta)](https://github.com/MetaCubeX/mihomo)**     | This is the "heart" of all current Meta series tools, supporting the most comprehensive set of protocols. |

## Why is configuring a single node so "difficult"?

Many users are accustomed to the "copy and paste a URL to use" model of Shadowsocks or v2rayN, so their first encounter with Clash can be very frustrating. This is mainly because Clash's design philosophy is **configuration file-based**.

### Why is a configuration file needed?

Clash is not just a connection tool; it needs to know:

1.  **Proxies (Node Information)**: Your server address, port, password, and protocol.
2.  **Proxy Groups (Strategy Groups)**: How you want to organize these nodes (e.g., manual selection or automatic selection of the fastest?).
3.  **Rules (Traffic Routing Rules)**: Access Google via proxy, access Baidu directly.

### Why is single-node configuration difficult?

-   **Strict Format**: Clash uses the **YAML** format. This format is extremely sensitive to indentation (spaces); an extra space or a missing space can cause the program to fail with an error and not start.
-   **Long Logical Chain**: In Clash, you cannot just input a single node. You must define the node → add the node to a group → reference this group in the rules. Even if you only have one node, this chain must be complete.

## How to import a self-built single node into Clash?

If you already have a self-built node (e.g., a `vmess://` or `ss://` link) and want to use it in Clash, there are typically three solutions:

### Solution A: Use Online/Local Subscription Conversion (Most Recommended)

This is the simplest method. Since Clash does not directly recognize single-node links, you can use a "Subscription Converter (Sub-Converter)" to convert your link into a Clash-recognizable `.yaml` subscription address.

1.  Copy your single-node link (e.g., `ss://...`).
2.  Open a trusted subscription conversion platform (or deploy Sub-Converter locally).
3.  Paste the link into the "Backend Upload" or "Source Link" box.
4.  Select **Clash** as the client.
5.  Generate the subscription link and import it into your Clash client.

### Solution B: Manually Write a Configuration File (Advanced)

If you want to completely eliminate reliance on others, you can manually write a minimal `.yaml` file. Here is a generic single-node template:

```YAML
# Minimal Single Node Template
port: 7890
allow-lan: false
mode: rule
log-level: info

proxies:
  - name: "My Self-Built Node"
    type: ss  # Protocol type: ss, vmess, trojan, etc.
    server: 1.2.3.4
    port: 443
    cipher: aes-256-gcm
    password: "your_password"

proxy-groups:
  - name: 🚀 Proxy Select
    type: select
    proxies:
      - "My Self-Built Node"
      - DIRECT

rules:
  - GEOIP,CN,DIRECT
  - MATCH,🚀 Proxy Select
```

### Solution C: Use a GUI that Supports "Single Node Addition"

Some modern clients (like **Clash Verge Rev**) have started to include simple UI interfaces that allow users to manually add a single node with a click of a button, without needing to write YAML by hand. You can look for an `Add Proxy` option in the "Proxies" or "Config" page.