# Krita → HCIE 3: Taşınabilir Özellikler ve Rust'a Dönüşüm Analizi

**Tarih:** 2026-05-24  
**Kaynak:** `/run/media/hc/data/Downloads/krita_source` (Krita 5.x)  
**Hedef:** `/home/hc/Documents/00_PROJECTS/hcie-rust-v3` (HCIE Rust v3)

---

## İçindekiler

1. [Yürütme Özeti](#1-yürütme-özeti)
2. [Mevcut HCIE Mimarisi ile Kıyaslama](#2-mevcut-hcie-mimarisi-ile-kiyaslama)
3. [Önerilen Taşıma Kategorileri](#3-önerilen-taşıma-kategorileri)
4. [Kategori A: Düşük Maliyet — Yüksek Etki](#4-kategori-a-düşük-maliyet--yüksek-etki)
5. [Kategori B: Orta Maliyet — Yüksek Etki](#5-kategori-b-orta-maliyet--yüksek-etki)
6. [Kategori C: Yüksek Maliyet — Stratejik](#6-kategori-c-yüksek-maliyet--stratejik)
7. [Kategori D: Düşük Öncelik](#7-kategori-d-düşük-öncelik)
8. [Rust'a Dönüşüm Değerlendirmesi](#8-rusta-dönüşüm-değerlendirmesi)
9. [Öncelikli Yol Haritası](#9-öncelikli-yol-haritası)

---

## 1. Yürütme Özeti

Krita, 20+ yıllık bir C++ Qt/KDE projesidir. Yaklaşık 2M+ satır kod içerir. HCIE 3 ise 0.1 sürümünde, 23 atomik Rust crate'inden oluşan bir image editor'dur.

Bu rapor, Krita'nın hangi özellik/fonksiyonlarının HCIE 3'e taşınabileceğini ve her birinin Rust'a dönüşüm zorluğunu değerlendirir.

**Temel bulgular:**
- **Düşük maliyetli kazanımlar:** Brush preset yönetimi, seçim filtreleri (grow/shrink/feather), gradient doldurma, layer stilleri (drop shadow, stroke)
- **Orta maliyetli:** Gelişmiş brush motoru (scatter, texture, dual-brush), deform/warp/liquify araçları, tile engine'in swap/kompresyon mimarisi
- **Yüksek maliyetli (uzun vadeli):** Renk yönetimi (ICC profiller, CMS), MyPaint brush engine, animasyon sistemi, tam Photoshop PSD/ASL desteği
- **Taşınması zor:** Qt/OpenGL bağımlılığı olan UI bileşenleri, KDE Frameworks mimari katmanları

---

## 2. Mevcut HCIE Mimarisi ile Kıyaslama

| Bileşen | Krita (C++) | HCIE 3 (Rust) | Durum |
|---------|-------------|---------------|-------|
| **Pixel Storage** | Tile engine (64×64, COW, LZF swap) | KisTile (basit tile, swap yok) | Eksik |
| **Blend Modes** | 100+ (KoCompositeOpRegistry) | ~27 (hcie-blend) | Geliştirilebilir |
| **Brush Engine** | KisPaintOp (dab pipeline, sensors) | Temel brush stamp + spacing | Geliştirilebilir |
| **Color** | ICC CMS, 20+ colorspace | sRGB, HSL, Lab | Temel |
| **Selection** | Pixel + vector selection | Temel pixel selection | Geliştirilebilir |
| **Filters** | 30+ plugin filter | 7 temel filter | Geliştirilebilir |
| **Layer Styles** | Drop shadow, bevel, stroke, glow, overlay | Yok | Eklenebilir |
| **Vector** | Flake (KoShape, KoPathShape) | Temel vector shape | Geliştirilebilir |
| **Undo** | KUndo2 + KisTransaction + memento | KisHistory (basit) | Geliştirilebilir |
| **Animation** | Full animation (keyframe, onion skin) | Yok | Uzak vade |
| **File I/O** | PSD, KRA, EXR, TIFF, etc. | PNG, PSD (kısmi) | Geliştirilebilir |
| **GUI** | Qt5/QML | egui/eframe | Farklı toolkit |
| **Plugin** | Python + C++ plugin API | Yok | Uzak vade |

---

## 3. Önerilen Taşıma Kategorileri

Her özellik şu kriterlere göre değerlendirilmiştir:
- **Maliyet:** Rust'a dönüşüm zorluğu (1-10)
- **Etki:** HCIE kullanıcısına sağlayacağı değer (1-10)
- **C++→Rust uyumu:** Nesne modeli, bellek yönetimi, template kullanımı

---

## 4. Kategori A: Düşük Maliyet — Yüksek Etki (Hemen Yapılabilir)

### 4.1 Seçim Filtreleri (Grow, Shrink, Feather, Border, Smooth)

**Kaynak:** `libs/image/kis_selection_filters.{h,cpp}`

| Filtre | Krita Sınıfı | Algoritma |
|--------|-------------|-----------|
| Grow | `KisGrowSelectionFilter` | Morphological dilation, ayarlanabilir X/Y radius |
| Shrink | `KisShrinkSelectionFilter` | Morphological erosion |
| Feather | `KisFeatherSelectionFilter` | Gaussian benzeri blur (radius bazlı) |
| Border | `KisBorderSelectionFilter` | Kenar çevresinde border seçimi |
| Smooth | `KisSmoothSelectionFilter` | Jagged kenar yumuşatma |
| Anti-Alias | `KisAntiAliasSelectionFilter` | FXAA-inspired kenar yumuşatma |

**Mevcut HCIE:** `hcie-selection` crate'inde temel mask ops var (grow, shrink, feather). Krita'daki border ve smooth eklenebilir.

**Dönüşüm Değerlendirmesi:**
- **Karmaşıklık:** 3/10 — Basit morfolojik operasyonlar
- **C++→Rust uyumu:** Yüksek — Saf piksel döngüleri, `unsafe` gerektirmez
- **Tahmini süre:** 1-2 gün

```cpp
// Krita: KisGrowSelectionFilter (basitleştirilmiş)
void process(KisPaintDeviceSP device, KisPaintDeviceSP mask,
             const QRect& rect, const KisFilterConfiguration* config) {
    int xradius = config->getInt("xradius", 1);
    int yradius = config->getInt("yradius", 1);
    // ... morphological dilation ...
}
```

```rust
// Rust eşdeğeri
// hcie-selection crate'ine eklenebilir
fn grow_mask(mask: &[u8], width: u32, height: u32, xradius: u32, yradius: u32) -> Vec<u8> {
    // morphological dilation
}
```

### 4.2 Gradient Doldurma (Linear, Radial, Conical, Spiral)

**Kaynak:** `libs/image/kis_gradient_painter.{cc,h}`
**Ayrıca:** `libs/image/kis_gradient_shape_strategy.{h,cpp}`, `kis_cached_gradient_shape_strategy.{h,cpp}`, `kis_polygonal_gradient_shape_strategy.{h,cpp}`

Krita gradient painter şu modları destekler: Linear, Bilinear, Radial, Square, Conical (sweep), Spiral.

**Mevcut HCIE:** `hcie-draw` crate'inde gradient desteği kısıtlı.

**Dönüşüm Değerlendirmesi:**
- **Karmaşıklık:** 4/10 — Renk interpolasyonu + geometri
- **Dikkat edilmesi gereken:** Krita'daki gradient renk durdurma noktaları (color stop) sistemi kompleks
- **Tahmini süre:** 2-3 gün

### 4.3 Temel Layer Stilleri (Drop Shadow, Stroke)

**Kaynak:** `libs/image/layerstyles/kis_ls_drop_shadow_filter.{h,cpp}`, `kis_ls_stroke_filter.{h,cpp}`

Layer style'lar Photoshop efekti olarak son derece yaygın. Krita implementasyonu:

- **Drop Shadow / Inner Shadow / Outer Glow / Inner Glow:** Aynı `KisLsDropShadowFilter` sınıfı, `Mode` enum ile seçilir. Blur + offset + renk + opacity.
- **Stroke:** Layer içeriğinin etrafına çizgi; color/gradient/pattern fill, outside/inside/center position.

**Mevcut HCIE:** Yok. Tamamen yeni eklenti.

**Dönüşüm Değerlendirmesi:**
- **Karmaşıklık:** 5/10 — Gaussian blur + offset compositing
- **Sınama:** Gaussian blur için `hcie-filter` crate'inde `gaussian_blur` var mı kontrol edilmeli
- **Tahmini süre:** 3-5 gün

```cpp
// Krita: KisLsDropShadowFilter::processDirectly()
void processDirectly(KisPaintDeviceSP dev, KisPaintDeviceSP srcDev,
                     KisLayerStyleFilterEnvironment* env) {
    // 1. src alpha channel'dan seçim oluştur
    // 2. seçimi offset + blur uygula
    // 3. shadow rengiyle doldur
    // 4. src üzerine kompozitle
}
```

### 4.4 Brush Preset Serileştirme

**Kaynak:** `libs/brush/` — `KisBrushModel.{h,cpp}`, `KisAbrStorage.{h,cpp}`

Krita'nın brush preset sistemi (`.kpp` dosyaları) oldukça olgun: XML tabanlı konfigürasyon, gömülü brush imajları, sensor eğrileri.

**Mevcut HCIE:** `ToolState::brush_presets` var ancak serileştirme yok.

**Dönüşüm Değerlendirmesi:**
- **Karmaşıklık:** 3/10 — JSON/XML serialize, dosya I/O
- **Tavsiye:** HCIE kendi `.hcie_brush` formatını tanımlamalı, Krita `.kpp`'den import desteği sonra eklenebilir
- **Tahmini süre:** 1-2 gün

---

## 5. Kategori B: Orta Maliyet — Yüksek Etki (Kısa-Orta Vade)

### 5.1 Gelişmiş Brush Dab Pipeline (Scatter, Texture, Dual Brush)

**Kaynak:** `plugins/paintops/libpaintop/`

| Özellik | Krita Dosyası | Açıklama |
|---------|--------------|----------|
| Scatter | `KisScatterOption{.h/cpp}` | Dab'ların stroke yolundan rastgele X/Y sapması |
| Texture | `KisTextureOption{.h/cpp}` | Dab üzerine pattern/texture bindirme |
| Dual Brush | `KisMaskingBrushOption{.h/cpp}` | İkinci bir brush'ın maskeleme olarak kullanımı |
| Mirror | `KisMirrorOption{.h/cpp}` | Yatay/dikey aynalama |
| HSV | `KisHSVOption{.h/cpp}` | Fırça darbesi sırasında HSV ayarı |
| Sensor System | `KisDynamicSensor*.h/cpp` | Pressure, tilt, speed, random, fade, distance |
| Airbrush | `KisAirbrushOptionData{.h/cpp}` | Time-based spacing |

**Mevcut HCIE:** `hcie-brush-engine` temel stamp + spacing sunar, ancak sensor-driven parametreler ve opsiyon zinciri yok.

**Dönüşüm Değerlendirmesi:**
- **Karmaşıklık:** 7/10 — Krita'daki opsiyon/sensor sistemi oldukça modüler ve kapsamlı
- **Tasarım önerisi:** Rust'ta trait-based option sistemi kullanılabilir:

```rust
trait BrushOption {
    fn apply(&self, info: &PaintInfo, dab: &mut Dab) -> Dab;
}

struct SizeOption {
    curve: SensorCurve,
    sensor: SensorType,
}
struct ScatterOption {
    amount: SensorCurve,
    axis: ScatterAxis, // X, Y, Both
}
```

- **Tahmini süre:** 1-2 hafta

### 5.2 Gelişmiş Deform Araçları (Cage, Liquify, Warp)

**Kaynak:** `plugins/tools/tool_transform2/` ve `libs/image/`

| Araç | Krita Sınıfı | Dosya |
|------|-------------|-------|
| Cage Transform | `KisCageTransformWorker` | `kis_cage_transform_worker.{h,cpp}` |
| Liquify | `KisLiquifyTransformWorker` | `kis_liquify_transform_worker.{h,cpp}` |
| Warp | `KisWarpTransformWorker` | `kis_warptransform_worker.cc` |
| Perspective | `KisPerspectiveTransformWorker` | `kis_perspectivetransform_worker.{h,cpp}` |
| Mesh | `KisBezierTransformMesh` | `kis_bezier_transform_mesh.{h,cpp}` |

**Mevcut HCIE:** Temel dönüşüm (ölçekleme, döndürme) var.

**Dönüşüm Değerlendirmesi:**
- **Karmaşıklık:** 7-8/10 — Green coordinates (cage), grid-based interpolation (liquify)
- **Matematik bağımlılığı:** Lineer cebir, biharmonik interpolasyon
- **Tahmini süre:** Her biri için 1-2 hafta

### 5.3 Tile Engine Swap + Kompresyon

**Kaynak:** `libs/image/tiles3/`

Krita tile engine'in kritik özellikleri:

- **COW (Copy-on-Write):** `KisTileData` paylaşımı + `KisTileDataPooler` (arka planda clone ön-üretimi)
- **Swap:** LRU-approximation clock algorithm, `KisTileDataSwapper` thread, `KisSwappedDataStore`
- **Kompresyon:** LZF (hızlı, düşük oran), `KisTileCompressor2`
- **Memory-mapped I/O:** `KisMemoryWindow` (16 MiB pencereler)

**Mevcut HCIE:** `hcie-tile` crate'inde basit `KisTile` var, boyut 64×64. Swap/kompresyon/COW yok.

**Dönüşüm Değerlendirmesi:**
- **Karmaşıklık:** 7/10 — Thread safety, lock management, memory mapping
- **Rust avantajı:** `Arc<Mutex<T>>` ve `RwLock` COW için daha güvenli; `mmap` için `memmap2` crate'i
- **Swap için Rust dezavantajı:** `unsafe` gerekebilir (raw memory mapping)
- **Tahmini süre:** 2-3 hafta

```rust
// Rust'ta COW tile tasarımı
struct TileData {
    pixels: Vec<u8>,
    age: AtomicU32,
    state: TileState, // Normal | Compressed | Swapped
}

struct Tile {
    data: Arc<TileData>,
    pos: (u32, u32),
}

impl Tile {
    fn write(&mut self) -> &mut [u8] {
        // COW: clone Arc if refcount > 1
        Arc::make_mut(&mut self.data).pixels.as_mut_slice()
    }
}
```

### 5.4 Renk Yönetimi Temelleri (ICC Profile Desteği)

**Kaynak:** `libs/pigment/` — `KoColorSpaceRegistry`, `KoColorConversionSystem`, `KoColorProfile`

Krita, LittleCMS 2 (LCMS2) üzerinden ICC v4 profil desteği sunar.

**Mevcut HCIE:** `hcie-color` crate'inde sRGB, HSL, Lab dönüşümleri var. ICC yok.

**Dönüşüm Değerlendirmesi:**
- **Karmaşıklık:** 7/10 — LCMS2 FFI binding gerekli
- **Crate önerisi:** `lcms2` veya `qicc` crate'i kullanılabilir
- **Tahmini süre:** 2-4 hafta (temel entegrasyon için), görüntü üzerinde dönüşüm pipeline'ı ek süre

### 5.5 PSD Dosya Formatı (Gelişmiş)

**Kaynak:** `libs/psd/`, `libs/ui/flake/` (PSD stilleri), `libs/image/kis_psd_layer_style.{h,cpp}`

Krita'nın PSD desteği oldukça kapsamlıdır: layer maskeler, adjustment layer, layer style (ASL), blend modes, group layer, clipping path.

**Mevcut HCIE:** `hcie-io` crate'inde temel PSD import var.

**Dönüşüm Değerlendirmesi:**
- **Karmaşıklık:** 6/10 — Binary format parsing, RLE/RAW compression
- **Öncelik:** Export yetenekleri import'a göre daha öncelikli olabilir
- **Tahmini süre:** 1-2 hafta

---

## 6. Kategori C: Yüksek Maliyet — Stratejik (Uzun Vade)

### 6.1 MyPaint Brush Engine Entegrasyonu

**Kaynak:** `plugins/paintops/mypaint/`

MyPaint brush engine, gerçekçi boyama simülasyonu için gelişmiş bir model sunar: süngerimsi yüzey, boya birikimi, ıslaklık.

**Dönüşüm Değerlendirmesi:**
- **Karmaşıklık:** 9/10 — MyPaint C kütüphanesi FFI veya saf Rust implementasyonu
- **Alternatif:** Rust'ta `mypaint` crate'i olup olmadığı araştırılmalı
- **Tahmini süre:** 4-8 hafta

### 6.2 Animasyon Sistemi (Keyframe, Onion Skin, Timeline)

**Kaynak:** `libs/image/kis_keyframe.{h,cpp}`, `kis_keyframe_channel.{h,cpp}`, `kis_image_animation_interface.{h,cpp}`, `kis_onion_skin_compositor.{h,cpp}`

**Bileşenler:**
- `KisKeyframeChannel` — Raster, scalar, shape keyframe kanalları
- `KisRasterKeyframeChannel` — Frame-based pixel data
- `KisOnionSkinCompositor` — Önceki/sonraki frame'leri yarı-saydam gösterim
- Frame tag'leri, frame hareketi

**Dönüşüm Değerlendirmesi:**
- **Karmaşıklık:** 9/10 — Büyük bir mimari ekleme
- **Öncelik:** HCIE önce non-animation olgunlaşmalı
- **Tahmini süre:** 2-3 ay

### 6.3 Plugin Sistemi (Python Scripting)

**Kaynak:** `sdk/`, `plugins/python/`

Krita, Python scripting için `PyQt` tabanlı `libkis` API'si sunar. Ayrıca C++ plugin sistemi.

**Dönüşüm Değerlendirmesi:**
- **Karmaşıklık:** 8/10 — WASM, Lua, veya Python embed
- **Rust seçeneği:** `rhai` (Rust-native scripting) veya `mlua` (Lua) daha uygun olabilir
- **Tahmini süre:** 2-4 ay

### 6.4 Tam Renk Yönetimi (CMS)

**Kaynak:** `libs/pigment/` + `libs/ui/` — Display renderer, soft-proofing, gamut check

- ICC v4 profil rendering intent (perceptual, relative colorimetric, absolute, saturation)
- Soft-proofing (proofing transformation)
- OCIO (OpenColorIO) entegrasyonu

**Dönüşüm Değerlendirmesi:**
- **Karmaşıklık:** 9/10 — LCMS2 binding + matematik + kullanıcı arayüzü
- **Tahmini süre:** 2-3 ay

---

## 7. Kategori D: Düşük Öncelik

| Özellik | Kaynak | Sebep |
|---------|--------|-------|
| **Karbon/Karbon vektör araçları** | `plugins/tools/karbonplugins/` | HCIE zaten temel vektör desteğine sahip; Krita'nın calligraphy aracı niş |
| **Hatching Brush** | `plugins/paintops/hatching/` | Niş kullanım, düşük talep |
| **Particle Brush** | `plugins/paintops/particle/` | Eğlenceli ama düşük öncelik |
| **Grid Brush** | `plugins/paintops/gridbrush/` | Pattern oluşturma için alternatif yöntemler var |
| **Touch/Multihand araçları** | `plugins/tools/basictools/` | Tablet desteği sonra gelebilir |
| **Referans Images Tool** | `plugins/tools/defaulttool/` | Kullanışlı ama ek UI gerektirir |
| **Magnetic Selection** | `plugins/tools/selectiontools/` | Karmaşık algoritma (graph cut / intelligent scissors) |
| **SeExpr (Il) blend modes** | 35+ blend mode | HCIE'de 27 var, ihtiyaç halinde çoğaltılabilir |
| **TGA/EXR/JPEG2000 I/O** | `libs/impex/` | Öncelik mevcut formatların iyileştirilmesi |

---

## 8. Rust'a Dönüşüm Değerlendirmesi

### 8.1 Kolay Dönüşen Kalıplar (C++ → Rust)

| C++ Kalıbı | Rust Karşılığı | Örnek |
|-----------|----------------|-------|
| `QSharedPointer<T>` | `Arc<T>` | Tile data paylaşımı |
| `QReadWriteLock` + `QWriteLocker` | `RwLock<T>` | Tile lock mekanizması |
| `QHash<K,V>` | `HashMap<K,V>` | Tile hash table |
| `QVector<T>` | `Vec<T>` | Pixel buffer'lar |
| `QRect` / `QPoint` | `egui::Rect` / `egui::Pos2` | Geometri tipleri |
| virtual method (interface) | `trait` + `dyn` | PaintOp option sistemi |
| `QMutex` + `QWaitCondition` | `Mutex` + `Condvar` | Thread sync |
| `QThread` | `std::thread` | Background işlemler |
| `KUndo2Command` | `Box<dyn Fn()>` / enum-based | Undo sistemi |

### 8.2 Zor Dönüşen Kalıplar (C++ → Rust)

| C++ Kalıbı | Sorun | Çözüm Önerisi |
|-----------|-------|---------------|
| `QObject` tree + signals/slots | Qt meta-object system, runtime introspection | Kullanma, event bus + closure kullan |
| `QTemplate` + SFINAE | Rust generics daha katı | `trait` bounds ile çalış |
| Multiple inheritance | Rust'ta yok | Trait composition + delegation |
| Qt containers (COW implicit sharing) | Rust ownership model farklı | `Arc::make_mut()` ile COW |
| void pointer casts (`static_cast`, `qobject_cast`) | `unsafe` gerekir | `Any` trait + downcast |
| `QImage` / `QPixmap` | Rust'ta `image::RgbaImage`, egui `ColorImage` | Mevcut dönüşüm |
| RTTI (`dynamic_cast`, `typeid`) | Rust'ta `Any::type_id()` var | Enum-based polymorphism daha iyi |
| Qt Plugin system (`QPluginLoader`) | Yok | WASM plugin veya `dlopen` (unsafe) |

### 8.3 C++→Rust Dönüşüm Maliyet Matrisi

```
Kolay (1-3/10)  : Selection ops, gradient, layer styles (basic), brush preset serialization
Orta (4-6/10)   : Color management, PSD I/O, tile compression, scatter/texture options
Zor (7-8/10)    : MyPaint engine, liquify, cage transform, animation
Çok Zor (9-10)  : Full ICC CMS, plugin system, complete PSD ASL parser
```

### 8.4 Özel Rust Avantajları

| Konu | Rust Üstünlüğü |
|------|----------------|
| **Bellek güvenliği** | C++'da tile engine'de sık görülen use-after-free ve data race'ler Rust'ta compile-time'da yakalanır |
| **Concurrency** | `Send`/`Sync` trait'leri tile swapper thread'lerinin güvenliğini compile-time garanti eder |
| **FFI** | Krita'nın LCMS, MyPaint bağımlılıkları için `unsafe` FFI Rust'ta daha kontrollü |
| **Test** | Krita'da test ekosistemi dağınık; Rust'ta `cargo test` entegre |
| **Zero-cost abstractions** | Brush option chain trait'leri C++ virtual call overhead'suz çalışır (monomorphization) |
| **Pattern matching** | Blend mode seçiminde `match` ifadeleri C++ `if/else` zincirlerinden çok daha temiz |

---

## 9. Öncelikli Yol Haritası

### Aşama 1: Quick Wins (1-2 ay)
```
[ ] Selection border & smooth (hcie-selection)
[ ] Gradient fill (linear, radial, conical) — hcie-draw
[ ] Drop shadow layer style — yeni crate (hcie-layer-style)
[ ] Stroke layer style
[ ] Brush preset serialization (JSON) — hcie-gui-egui
```

### Aşama 2: Brush Engine Geliştirme (2-3 ay)
```
[ ] Scatter option — hcie-brush-engine
[ ] Texture option
[ ] Sensor curve system (pressure, tilt, speed)
[ ] Mirror option
[ ] Airbrush (time-based spacing)
[ ] Dab cache (KisDabCache)
```

### Aşama 3: Görüntü İşleme (2-3 ay)
```
[ ] Tile swap + LZF compression — hcie-tile
[ ] Deform araçları: cage, liquify (ilk etapta warp)
[ ] Gelişmiş PSD/KRA export
```

### Aşama 4: Uzun Vade (6+ ay)
```
[ ] ICC CMS (LCMS2 binding)
[ ] MyPaint brush engine
[ ] Animasyon (keyframe, onion skin)
[ ] Plugin sistemi (WASM/Rhai)
```

---

## Ek: Krita Source Tree Reference (Önemli Yollar)

| Klasör | İçerik | HCIE Karşılığı |
|--------|--------|----------------|
| `libs/image/` | Core image: layer, paint device, tile engine, selection, transform, filter | `hcie-document`, `hcie-tile`, `hcie-selection`, `hcie-draw` |
| `libs/image/brushengine/` | PaintOp framework | `hcie-brush-engine` |
| `libs/image/tiles3/` | Tile engine (COW, swap, compression) | `hcie-tile` |
| `libs/image/layerstyles/` | Drop shadow, bevel, stroke, satin, overlay | Yok |
| `libs/pigment/` | Color spaces, composite ops, CMS | `hcie-color`, `hcie-blend` |
| `libs/brush/` | Brush types (ABR, GBR, PNG, SVG, text, pipe) | `hcie-brush-engine` (kısmi) |
| `libs/flake/` | Vector shapes, path, svg, text | `hcie-vector`, `hcie-text` |
| `libs/ui/` | Qt/KDE UI framework | `hcie-gui-egui` (farklı toolkit) |
| `plugins/filters/` | 30+ görüntü filtresi | `hcie-filter` |
| `plugins/tools/` | 20+ araç | `hcie-gui-egui` |
| `plugins/paintops/` | 15+ brush motoru | `hcie-brush-engine` |
| `sdk/` | Python API, libkis | Yok |