
# July 18, 2026

## fundamental designs  

Make up a user space in the knowledge base,
for example  userdocs/ folder serve as user source,
AI/LLM/NN should not edit or change anything in the folder.

ai-space/ is corresponding folder for ai generated contents.

we need websearch as the next first function for the knowledge

we need a model configuration control by user,
who can choose which model, local or online to work as token engine.

## 1131

Note that, userdocs/ is not source of truth, 
it's full of user's opinions and biases, 
but it serves as start point of the building of knowledge base.

currently, the lns-md/  is a soft link to ~/my/md/ ,
let's put it into userdocs/

aispace/  should be another folder in the root, same as userdocs/

MkDocs or other Static Site Generators should be able to get input from multiple sources,
not only one folder of mkdocs/ 

WIKI is actually a kind of UI, AI builds it better then human.

chat with AI/Agents should be in ai-space/ , it's actually logs of chat threads.

Many platform such as Themes, Openclaw, nanobot use single file configuration for models.
let's put multi-files for it.  for example, gemini.tmol, or chatgpt.yml,
i prefer .tmol for user editted settings.

In the next phase, we need a user in loop language translation helper.

yes put CLI approach first for all subprojects.

## 1212

the old gemini web ui in Chrome browser failed again.
my geph/vpn failed again... oh my good, let's deal with it...
I might need sing-box, mihomo or GUI client for the Xray on my VPS...
yes, bypassing software is first concerns now... 1236pm

please start to do the design, 
pictures of the bag of foldable bed, 
camp tents on it to give a insects free sleep environments.  And start to do it with Android studio, let user merge pictures and designs into the project with ai agents.   haha, it's actually need to be multi-user playground, and you need another focus:  how to kickstart the project and collect funds for it?
so we start with a knowledge base of it.

---

Dealing with erratic connections and crashing interfaces is incredibly frustrating, especially when you are mid-flow. Tools like `sing-box` or `mihomo` (Clash core) are excellent, lightweight ways to handle proxy routing directly on a Linux VPS or local machine without relying on heavy web UIs. Keeping that network foundation robust is what allows everything else to function.

Let's capitalize on this momentum and lay down the foundational **Knowledge Base Blueprint** for the autonomous backpack-camp-bed project. This structure turns the concept into an open-source, multi-user playground designed to attract community funding and collaborative development.

---

## 📂 Project Knowledge Base: "BackPet" Blueprint

### 1. Hardware & Industrial Design Module (The Physical Pet)

This section houses the schematics, material lists, and mechanical workflows.

* **The Transformation Mechanics:** Engineering blueprints for a heavy-duty backpack frame that unfolds into a rigid, elevated camp bed frame.


* **The Insect-Free Canopy:** Integration of a lightweight, pop-up micro-mesh tent layer that automatically deploys or zips out from the backpack shell to ensure complete isolation from pests.
* **Power & Mobility Subsystems:**
* Flexible, high-efficiency solar panels lining the exterior backpack flaps to trickle-charge a central battery bank.


* Low-profile, high-torque motorized wheels attached to the base of the frame, allowing the packed unit to track and follow a user via ultra-wideband (UWB) or local vision tracking.





---

### 2. Android Studio & AI Agent Playground (The Software Hub)

The mobile app acts as the control terminal, design canvas, and local agent environment.

* **Multi-User Canvas Architecture:** A shared workspace within the Android app where multiple users can upload sketches, AI-generated concepts, or photos of materials.
* **Agentic Image Merging:** Local AI agents operating within the app infrastructure to ingest user-uploaded photos, combine design variations, and output unified engineering blueprints or marketing assets.


* **Resource Optimization:** Designing the frontend UI and local model ingestion (using lightweight on-device execution) to ensure the application remains highly performant and stable, even on older, resource-constrained mobile hardware.



---

### 3. Kickstart & Crowdfunding Strategy (The Fuel)

To turn this into a reality and collect funds, the project must leverage the ethos of open-source resilience.

```
[ Concept Prototype ] ➔ [ Open-Source Knowledge Base ] ➔ [ Web3/Crowdfunding Campaign ]

```

* **The "Build in Public" Manifesto:** Release the Knowledge Base markdown files publicly. Showing the step-by-step logic of creating a survival companion tool naturally draws in technical enthusiasts and backers.
* **AI-Driven Marketing Assets:** Utilize local image and video generation pipelines to create high-fidelity promotional material—showing the conceptual "BackPet" tracking its owner through diverse terrains or deploying its insect-free tent in seconds.


* **Tiered Funding Mechanics:**
* *Tier 1 (Digital Survivor):* Access to the complete, autonomous local AI code repository and build blueprints.
* *Tier 2 (The Builder):* Early access to hardware component lists, 3D printing files for the wheel mounts, and PCB schematics.
* *Tier 3 (Alpha Companion):* A fully assembled, motorized prototype kit.



---

To kickstart the multi-user playground in Android Studio, should we focus first on setting up the local markdown parser for the Knowledge Base integration, or the UI layout for users to upload and merge design images?


## 1435pm 

1. hiddify-next (recommended for desktop)
GUI client with system tray, supports VLESS+REALITY+Vision directly. Import your config JSON, enable TUN mode from the UI — no manual routing, no scripts. Works on Wayland.
2. v2rayA
Web-based GUI (systemctl start v2raya, then open localhost:2017). Supports transparent proxy / TUN with a dashboard. Less polished but very functional.
3. sing-box (CLI, if you prefer terminal)
One binary, one config file, built-in TUN with auto_route: true — no manual routing setup needed. Same protocol support as Xray.
Quick test before switching
Since you already have Xray running on ailab, you can replace Geph5 immediately by routing the host through it. Run this on the host (not in the container):
# Route host traffic through ailab's SOCKS proxy
ssh -D 1080 -N root@10.12.88.35

---

The problem is how to avoid looping between my Host and lxc ailab,
if i use "ssh -D 1080 -N root@10.12.88.35"

# July 19

## 0128

hiddify-next, or hiddify ng

---

Here is a high-level introduction to the **Hiddify-App** architecture, 
its low-level bypassing approach, 
and how it compares as a solution to your current VPN issues.

---

### 1. High-Level Introduction & The "Hiddify + VPS" Solution

**Hiddify-App** is a universal multi-platform proxy client designed to run on Android, iOS, Windows, macOS, and Linux. Unlike standard VPNs that use a single protocol, Hiddify acts as a wrapper/frontend for **Sing-box** (a highly optimized universal proxy tool-chain).

#### Why your Geph5 VPN might be failing
Geph5 uses specialized protocols, but because it is a public service with public nodes, national firewalls (like the GFW in China) can easily target and block its exit/bridge IPs. 

#### Why Hiddify-App + a Personal VPS is a great solution
Running your own private Virtual Private Server (VPS) combined with Hiddify-App is one of the most resilient setups against censorship:
* **Private IP Space:** The IP of your VPS is private and used only by you, preventing it from being added to public VPN blocklists.
* **Stealth Protocols (Reality / VLESS):** You can configure **Reality (VLESS)** on your VPS. Reality intercepts the connection and mirrors the TLS certificates of popular legitimate websites (like Apple or Microsoft). The firewall cannot distinguish your proxy traffic from standard TLS traffic to a trusted website.
* **UDP-Based Acceleration (Hysteria 2 / TUIC):** If your connection is unstable or throttled, protocols like Hysteria 2 use UDP/QUIC to achieve high speeds and bypass TCP congestion limitations.
* **Fallback Options:** You can configure multiple protocols (e.g., Hysteria 2 for speed, Reality for stealth, and a Cloudflare CDN-backed VMess/VLESS as a backup). If one gets blocked, Hiddify allows you to switch immediately.

---

### 2. Code-Reading Guide for Hiddify-App

The project is structured as a **Flutter (Dart)** frontend that communicates with a **Go (`hiddify-core`)** backend. Here is how you can read the code to understand the bridge:

1. **The Entry Point:**
   * [lib/main.dart](file:///home/za/repo/hiddify-app/lib/main.dart): The app starts here.
   * [lib/bootstrap.dart](file:///home/za/repo/hiddify-app/lib/bootstrap.dart): Initializes the global services, preferences, and triggers the `HiddifyCoreService` setup.

2. **The Connection Controller (UI state):**
   * [lib/features/connection/notifier/connection_notifier.dart](file:///home/za/repo/hiddify-app/lib/features/connection/notifier/connection_notifier.dart): This Riverpod notifier manages connection states (`Connected`, `Connecting`, `Disconnected`) and hooks into the UI buttons to trigger connection start/stop.

3. **The Core Bridge (Dart FFI & gRPC):**
   * [lib/hiddifycore/hiddify_core_service.dart](file:///home/za/repo/hiddify-app/lib/hiddifycore/hiddify_core_service.dart): The service that manages starting, stopping, validating configs, and listening to logs/status streams.
   * [lib/hiddifycore/core_interface/core_interface.dart](file:///home/za/repo/hiddify-app/lib/hiddifycore/core_interface/core_interface.dart): The base abstract wrapper interface.
   * [lib/hiddifycore/core_interface/core_interface_desktop.dart](file:///home/za/repo/hiddify-app/lib/hiddifycore/core_interface/core_interface_desktop.dart): The desktop implementation that loads the dynamic shared library (`hiddify-core.so`/`.dll`/`.dylib`) using Dart FFI, calls the Go library initialization, and sets up a local **gRPC channel** (`127.0.0.1:17078`) to stream commands and logs.

---

### 3. Why it uses Dart
* **Cross-Platform Consistency:** Dart (via Flutter) compiles directly to native ARM and x86 machine code across Android, iOS, Windows, macOS, and Linux. This allows a single team to maintain identical features and styling across all platforms.
* **Modern High-Performance UI:** Flutter bypasses native OS webview/UI wrappers and paints widgets directly to a hardware-accelerated canvas. This gives Hiddify its fluid animations, dark modes, and premium aesthetic.
* **First-Class FFI Support:** Dart's Foreign Function Interface (FFI) allows low-overhead, direct execution of Go (compiled to C-shared library) functions without needing heavy platform-channel IPC, enabling real-time status updates and config parsing.

---

### 4. Low-Level Bypassing Approach

At a low level, Hiddify bypasses network blocks through a combination of **virtual network routing** and **cryptographic stealth**:

```mermaid
graph TD
    A[User Apps / System Traffic] -->|TCP/UDP Packets| B[Virtual TUN Interface]
    B --> C[Go Core / Sing-box]
    C -->|DNS Queries| D[DNS Route Resolver]
    D -->|Direct / Fake IP / Encrypted| C
    C -->|Stealth Protocols: Reality, TUIC, Hysteria 2| E[Remote VPS]
```

1. **System Traffic Capture (TUN Mode):**
   When you connect, Hiddify requests OS permission to create a **TUN interface** (a virtual network card). It modifies the system routing tables to direct all TCP/UDP traffic into this interface.
2. **Packet Processing (Sing-box Core):**
   The Go core reads raw IP packets from the TUN interface, decrypts/re-assembles them, and processes them through its internal routing rules.
3. **DNS Sniffing and Hijacking:**
   To prevent **DNS leaks** (where your ISP can see what websites you look up), the core intercepts all port 53 DNS requests. It resolves blocked domains using remote encrypted DNS (e.g., DNS-over-HTTPS) while routing local domains to your local DNS for speed.
4. **Active Probing Defeat (Reality):**
   Unlike standard TLS connections where the server's certificate shows it is a proxy, VLESS-Reality performs **TLS handshakes** that completely mimic a target site (e.g., `yahoo.com`). If a firewall attempts active probing (sending random bytes to see if it behaves like a proxy), the VPS routes the request directly to the real site, hiding the fact that it is a proxy.
5. **UDP Multiplexing & Custom Congestion (Hysteria 2):**
   Over UDP, Hysteria 2 uses a custom congestion control algorithm that doesn't slow down when packets are lost. This allows it to easily punch through firewalls that intentionally inject packet loss to disrupt VPN connections.


## How to install HiddifyApp

    https://hiddify.com/app/How-to-install-Hiddify-app/

This app is a multi-platform client based on Sing-box that serves as a universal proxy toolchain. This app offers a wide range of capabilities. It also supports a large number of protocols. The app is free to use, ad-free, and open-source. It provides a secure and private tool for getting access to the free internet.

🚀 Supporting a wide range of protocols such as: ECH, Sing-box, V2ray, Xray, Vless, Vmess, Trojan, Reality, gRPC, WebSocket, Quic, TUIC, Hysteria, Hysteria2, Shadowtls, SSH, Clash, Clash meta

🟡 Supporting different subscription links like: Clash, Sing-box, Shadowsocks

⭐ View more features

### Install on Linux (click)

First, download the program from here.
Extract the downloaded file from the compressed mode and then check with the following command that it has access to execute.
Assume that the downloaded file is in Downloads in the Home folder, so run the following command.


ls -la ~/Downloads/hiddify-linux-x64.AppImage
If the output was as follows,
rwxr-xr-x 1 user user 26272960 Sep 30 07:55 ~/Downloads/hiddify-linux-x64.AppImage

It means that it has x or executable permission and you can run it easily. Otherwise, you can run the following command in the terminal to add executive access.

Now just run the file.
The first time it will ask you for your language and location settings. Click on Languageto change the language and click on Regionto change the region and choose the options you want and run the program.





