# Как Bux ще победи Rust, Nim и C

> **Дата:** 2026-05-31 | **Версия:** 0.2.0 (bootstrap)

---

## Пазарна позиция

Всеки език заема ниша. Bux влиза **между тях** с уникална философия:

```
Скорост на писане (бързо → бавно):
  C  ████████████████████  (няма абстракции, но бързо става)
  Nim ██████████████       (изразителен, GC)
  Bux ████████████████     (изразителен, без GC)
  Rust ████████            (borrow checker бави)

Безопасност (ниска → висока):
  C  ████                  (ръчна, pointer-и)
  Nim ████████             (GC предпазва от leak, не от use-after-free)
  Bux ████████████         (опционален borrow checker)
  Rust ██████████████████  (пълен borrow checker)

Производителност (бавно → бързо):
  Nim ████████████         (GC добавя overhead)
  Rust ██████████████████  (zero-cost abstractions)
  C   ██████████████████  (близо до метала)
  Bux ██████████████████  (C transpiler → native)
```

---

## Уникалното предимство: Gradual Ownership

**Никой друг език не предлага това.**

| Модел | Език | Как работи |
|-------|------|------------|
| Всичко непроверено | C, Zig | Бързо писане, бъгове в runtime |
| Всичко проверено | Rust | Бавно писане, безопасно в compile-time |
| **Опционална проверка** | **Bux** | **Бързо писане, проверка само на критичния код** |

### Синтаксис

```bux
// Режим 1: Без проверки (като C/Nim) — за бързо прототипиране
func QuickHack(arr: *int, len: int) {
    for i in 0..len {
        arr[i] = arr[i] * 2;  // no bounds check, no borrow check
    }
}

// Режим 2: С проверки (като Rust) — за critical paths
@[Checked]
func SafeMerge(a: &[int], b: &[int]) -> Vec<int> {
    // borrow checker проверява че a и b не се припокриват
    // bounds checking на всеки достъп
    // lifetime tracking гарантира че резултатът не надживява входовете
}
```

### Защо това печели

| Програмист | Какво иска | Решение |
|------------|------------|---------|
| **C програмист** | "Не ми се занимава с borrow checker" | Пише без `@[Checked]`, получава C-скорост |
| **Rust програмист** | "Искам гаранции за safety" | Добавя `@[Checked]` на критичните функции |
| **Team lead** | "Искам баланс скорост/безопасност" | Prototype бързо, harden после |
| **Startup** | "Трябва да shipping-нем вчера" | Без проверки за MVP, добавят се после |

---

## Вторични предимства

### 2. Compile-time функции (CTFE)

```bux
// Nim има CTFE, Rust няма (само const fn с ограничения)
const func Fib(n: int) -> int {
    if n <= 1 { return n; }
    return Fib(n-1) + Fib(n-2);
}

const FIB_40 = Fib(40);  // изчислява се при компилация
```

**Предимство:** Предварително изчислени таблици, парсъри, валидации на compile-time, които Rust не може.

### 3. По-прост от Rust

```bux
// Rust: трябват lifetime annotations
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { ... }

// Bux: без анотации в обикновен код
func Longest(x: String, y: String) -> String { ... }
// Само в @[Checked] зони се добавят при нужда
```

### 4. По-бърза компилация от Rust

```
Rust (LLVM):  10-60 секунди за среден проект
Bux (C):      <1 секунда за среден проект (като Nim)
```

C backend → gcc/clang компилират C много по-бързо отколкото LLVM компилира Rust.

### 5. Algebraic типове (Nim ги няма нативно)

```bux
// Bux: първокласни algebraic enums
enum Result { Ok(int), Err(String) }
let x = Ok(42);
match x { Ok(v) => ..., Err(e) => ... }

// Nim: трябват макроси или object variants
```

---

## Пътна карта за победа

| Фаза | Feature | Ефект |
|------|---------|-------|
| **8.1** | ✅ Error handling (`?`, `!`) | По-чисто от Nim |
| **8.2** | ⏳ `@[Checked]` borrow checker | **Уникално — това е оръжието** |
| **8.3** | ⏳ Concurrency (tasks + channels) | Go-стил леки нишки |
| **8.4** | ⏳ CTFE (`const func`) | Nim-level метапрограмиране |
| **8.5** | ⏳ Trait система | Rust-стил генерици |
| **8.6** | ⏳ Макроси | Nim-стил метапрограмиране |
| **8.7** | ⏳ LSP сървър | IDE поддръжка |

---

## Target аудитория

1. **C програмисти** искащи по-добър tooling → Bux дава типове, генерици, pattern matching без GC
2. **Nim програмисти** искащи C-like синтаксис → Bux има същата скорост, по-познат syntax
3. **Rust програмисти** уморени от borrow checker → Bux дава safety само където трябва
4. **Нови програмисти** → Bux е по-прост от Rust, по-строг от Python

---

## Рискове

| Риск | Вероятност | Митигация |
|------|------------|-----------|
| Borrow checker твърде сложен за имплементация | Средна | Започваме с basic: само `&T` и `&mut T`, без lifetimes |
| Няма достатъчно ecosystem | Висока | Първо self-hosting, после пакети |
| Няма corporate backing | Висока | Open-source community подход |
| C backend ограничава производителността | Ниска | C компилаторите са 30+ години оптимизирани |

---

## Заключение

**Bux не трябва да е "по-добър Rust" или "по-добър Nim".** Той трябва да е **единственият език с gradual safety** — бърз за писане като C, безопасен като Rust, но само където програмистът избере.

Това е празна ниша на пазара. Никой не я запълва. Bux може да е първият.