Files

T

phantom 7ace048d94 init

2026-07-09 02:59:53 +03:00

20 KiB

Executable File

Raw Blame History

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)

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

// 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 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

// 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:

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'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

20 KiB Executable File Raw Blame History Unescape Escape

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

İçindekiler

1. Yürütme Özeti

2. Mevcut HCIE Mimarisi ile Kıyaslama

3. Önerilen Taşıma Kategorileri

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

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

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

4.3 Temel Layer Stilleri (Drop Shadow, Stroke)

4.4 Brush Preset Serileştirme

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

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

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

5.3 Tile Engine Swap + Kompresyon

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

5.5 PSD Dosya Formatı (Gelişmiş)

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

6.1 MyPaint Brush Engine Entegrasyonu

6.2 Animasyon Sistemi (Keyframe, Onion Skin, Timeline)

6.3 Plugin Sistemi (Python Scripting)

6.4 Tam Renk Yönetimi (CMS)

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

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

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

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

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

8.4 Özel Rust Avantajları

9. Öncelikli Yol Haritası

Aşama 1: Quick Wins (1-2 ay)

Aşama 2: Brush Engine Geliştirme (2-3 ay)

Aşama 3: Görüntü İşleme (2-3 ay)

Aşama 4: Uzun Vade (6+ ay)

Ek: Krita Source Tree Reference (Önemli Yollar)

20 KiB

Executable File

Raw Blame History