Tüm Yazılar
Geliştirme · Development · 14 Mayıs 2026 · 15 dk okuma · Yazar: Althera Games

Prosedürel İçerik Üretimi (PCG) ve AI: UE5'te Sınırsız Dünyalar

TL;DR — Özet

  • • PCG, hem build-time hem runtime çalışan prosedürel yerleştirme sistemidir; tek bir grafik onlarca saatlik elle dekorasyon işini soğurur.
  • • UE5 PCG plugin'i node-graph, point set ve spline mantığı üzerine kuruludur; attribute set'ler ile her parça için ayrı veri taşır.
  • • AI katmanı, LLM tabanlı prompt'lardan PCG parametrelerine veya biome tasarımına otomatik köprü kurar; tasarımcının dilini sayıya çevirir.
  • • Houdini Engine, pro düzey prosedürel geometri için altın standarttır; UE5 native PCG çoğu indie senaryosu için yeterli.
  • • İndie sweet spot, hand-crafted ana sahne + prosedürel detay katmanıdır; PCG'yi "her yere koy" değil "sıkıcı yerleri doldur" aracı olarak düşünmek gerekir.

Prosedürel içerik üretimi (Procedural Content Generation, kısaca PCG), oyun dünyalarının elle değil kurallar üzerinden üretilmesi pratiğidir. Bir tek graph, bir tek noise fonksiyonu, bir tek attribute table; onlarca kilometre ormanı veya yüzlerce dairenin iç detaylarını üretebilir. 2026'da bu pratik, AI destekli prompt katmanı ile birleşince tasarımcının üzerinden mekanik karar yükünü tamamen kaldırıyor.

Biz Althera Games olarak, hem Potion Rise Simulator'ın workshop sahnesindeki yüzlerce malzeme dağıtımını hem NightRecord: Thin Walls'taki her bir dairenin yaşanmışlık hissini PCG ile inşa ediyoruz. Bu yazıda, UE5 PCG plugin'inin nasıl çalıştığını, AI'ın bu denkleme nasıl girdiğini ve indie ekipler için doğru kullanım sınırlarını paylaşacağız. Motor genel bakışı için UE5 ile indie geliştirme rehberimiz tamamlayıcı bir okuma olarak ilgi çekebilir.

Prosedürel İçerik Üretimi Nedir, Neden 2026'da Önemli?

PCG, oyun geliştirme tarihinde yeni bir kavram değil. 1980'lerin sonunda Rogue ve NetHack, dungeon haritalarını her oturumda yeniden üretiyordu. 1996'da Diablo, modern action-RPG'lerin temelini atan random dungeon mantığını yaygınlaştırdı. Minecraft (2009), Perlin noise üzerine kurulu sınırsız bir biyom üretici olarak prosedürel oyun dünyalarını ana akıma taşıdı. No Man's Sky (2016), tek bir seed'den 18 kentilyon gezegen üretebilen "yıldız çapında" PCG sistemini gösterdi. Bu mirasın üzerinde, bugün PCG bir oyun mekaniği değil, bir geliştirme pipeline kararı.

2026'nın PCG manzarasında üç güç var. Birincisi, motor seviyesinde olgunlaşan araç setleri: UE5 PCG Framework, Houdini Engine ve Unity'nin geleneksel ProBuilder + custom script'leri. İkincisi, açık dünyaların kalıcı norm haline gelmesi; Hogwarts Legacy'den Cyberpunk 2077: Phantom Liberty'ye kadar her büyük yapımda PCG, dekorasyon yükünü omuzlayan görünmez bir asistandır. Üçüncüsü, AI tabanlı içerik üretiminin pipeline'a girmesi; tasarımcı artık her parametreyi elle ayarlamak yerine niyetini cümleyle ifade ediyor.

İndie ekipler için bunun pratik anlamı şudur: 2-3 kişilik bir takım, 50 saatlik bir oyun dünyasını PCG olmadan elle kurmaya çalışsaydı, yalnızca dekorasyon için bir yıllık iş gücü harcardı. PCG ile aynı iş, kararlar arketipler düzeyine yükseldiğinde haftalara iner. Bu yazıda asıl mesele kalitenin korunarak nasıl yapılacağıdır.

UE5 PCG Plugin: Graph, Points, Splines

UE5 PCG Framework, UE5.2 ile experimental olarak gelen, UE5.4 ile stable işaretlenen, node-graph tabanlı bir prosedürel üretim sistemidir. Mental modeli üç temel kavram üzerine kurulur: point, spline ve attribute set. Her bir point, dünyada bir konumu (transform) ve onunla bağlı metadata'yı (density, scale, color, biome ID, vb.) temsil eder. Bir grafik, point'leri üretir, filtreler, dönüştürür ve sonunda Static Mesh Instance olarak sahneye basar.

Tipik bir orman scatter grafiği şöyle çalışır: Get Actor Data node'u zemini volume olarak alır, Surface Sampler noise tabanlı bir point dağılımı üretir, Density Filter belirli bir eşiğin altındaki point'leri eler, Transform Points rastgele rotasyon ve scale uygular, son olarak Static Mesh Spawner mesh'leri sahneye basar. Bütün bu zincir bir tek PCG Volume içinde yaşar ve volume'ü taşıdığınızda grafik kendiliğinden yeniden değerlendirilir.

Spline tabanlı üretim, yol kenarına çit dizmek, bir nehir kenarına kaya dizmek veya bir koridorun boyu boyunca lamba yerleştirmek için kullanılır. Spline üzerinden örneklenmiş point'ler, attribute set ile zenginleştirilir; örneğin spline'ın bitiş noktasına yaklaştıkça point density azalır. Attribute set'ler ise PCG'nin gerçek gücüdür: her point'in üzerinde tablo şeklinde veri taşıyabilirsiniz, ardından bu veriyi grafiğin ileriki adımlarında koşul olarak kullanırsınız. Debug için Debug node ve Inspect view edebilirsiniz; PCG Editor, point bulutlarını ve attribute değerlerini gerçek zamanlı gösterir.

PCG + Lumen + Nanite: Performans Hikâyesi

PCG'nin yarattığı en büyük yanılsama "ücretsiz" olmasıdır. Aslında PCG runtime performansını üç kanaldan etkiler: generation cost (grafik yürütme süresi), memory footprint (üretilen mesh instance'larının bellekteki ağırlığı) ve render cost (sahnede her frame çizilen üçgenler). İndie ekipler için pratik strateji, generation cost'unu build-time'a kaydırmak ve render cost'unu Nanite + ISM/HISM ile yönetmektir.

Build-time generation modunda PCG grafiği Editör'de çalışır, sonuçlar ISMComponent ve HISMComponent içine bake edilir, paketlenmiş oyunda yalnızca instance render maliyeti kalır. Bu, performans öngörüsü için en güvenli yoldur. Runtime generation ise World Partition cell yüklendiğinde tetiklenir; sonsuz dünyalar için güçlüdür ama her cell'in yüklenme anında milisaniyelik hiccup üretme riski taşır. r.PCG.RuntimeGeneration.Async 1 ile asenkron çalıştırma açılır; karmaşık grafiklerde bu satır olmadan production'a çıkmak risklidir.

HISM vs Nanite kararı bir başka kritik noktadır. Nanite, milyonlarca üçgenli mesh'leri otomatik LOD'lar ile çizen geometri sistemidir; PCG ile birleştiğinde "sonsuz detaylı" sahneler mümkün hale gelir. Ama Nanite, çok sayıda küçük ve hareketli mesh için ideal değildir; çim, küçük taş, küçük yaprak gibi binlerce kopya için klasik HISM hâlâ daha hızlıdır. Bizim Potion Rise Simulator workshop'unda büyük raflar ve duvar panelleri Nanite, masaüstündeki yüzlerce küçük şişe ise HISM ile çiziliyor.

PCG'nin maliyeti grafiğin yürütülmesinde değil, üretilen sahnenin nasıl çizildiğindedir. Bir profiler turu olmadan PCG'yi "ücretsiz" varsaymak, ekip için en pahalı yanılsamadır.

Profiling için stat PCG, stat InstancedStaticMeshComponent ve Unreal Insights → PCG Trace üçlüsü esastır. Lumen ile birlikte çalışırken, PCG ile spawn edilen mesh'lerin surface cache'e doğru kayıt edildiğinden emin olun; aksi halde sahne tutarsız bir indirect lighting üretir.

Houdini Engine Entegrasyonu: Pro Pipeline

UE5 native PCG, indie ekipler için %80 senaryoyu kapsar. Geriye kalan %20'de, özellikle terrain sculpting, destruction, complex spline networks (yol şebekeleri, nehir sistemleri) ve parametric architecture (procedural binalar) söz konusu olduğunda SideFX Houdini, hâlâ sektör altın standardıdır. Houdini Engine, bir Houdini projesini HDA (Houdini Digital Asset) olarak paketleyip UE5 içinde parametrik bir node gibi çalıştırmanıza olanak tanır.

Bir HDA, tasarımcının Houdini'de kurduğu prosedürel grafiği UE5'e siyah kutu olarak verir: tasarımcı UE5 sahnesinde HDA'ya bir spline ve bir set parametre verir, Houdini bunu işler, sonucu UE5'e geri gönderir. Bu pipeline'ın asıl gücü, Houdini'nin vex script'leri ve simulation node'ları sayesinde UE5 PCG'nin doğal olarak yapamadığı işleri yapabilmesidir: bir kayanın realistik şekilde aşınması, bir nehrin doğru hidrolojik akışla yerleşmesi, bir şehrin sokak şebekesinin Wave Function Collapse algoritmasıyla üretilmesi gibi.

Lisans tarafında: Houdini'nin Indie lisansı yıllık ~269 USD ve son yıllık geliri 100.000 USD'nin altındaki ekipler için kullanılabilir; Houdini Engine entegrasyonu bu pakete dahildir. Profesyonel sürüm on binlerce dolarlık etiketle gelir. Detaylı lisans şartları için SideFX Houdini Engine sayfası başvurulacak kaynaktır.

Karar matrisi: Eğer ekibinizde Houdini bilen biri yoksa, UE5 native PCG ile başlayın. Eğer prosedürel terrain veya parametric arşitektüre gerçekten ihtiyacınız varsa ve ekibinizin haftalarca Houdini öğrenmeye ayıracağı kapasitesi varsa, HDA pipeline'ı uzun vadede ciddi getiri sağlar. Bizim NightRecord: Thin Walls'da apartman geometrisinin temel modüllerini UE5 native PCG ile, dışarıdaki Sovyet bloğunun çevresindeki kentsel detayları ise küçük bir Houdini HDA seti ile üretiyoruz.

AI Katmanı: LLM ile Biome ve Senaryo Üretimi

2026 itibarıyla PCG'nin üzerine konan en heyecan verici katman, AI tabanlı parametre üretimi. Bu, "tüm dünyayı AI üretsin" anlamına gelmez; aksine, AI burada PCG'nin kontrol panelini tutan bir asistantır. Tasarımcı doğal dilde "çürümüş bir bataklık köyü, kayık iskeleleri, kırık fenerler" yazar; LLM bunu PCG grafiğinin parametre setine çevirir: biome_id=swamp_decay, density=0.6, prop_set=village_ruined, moisture=0.85, fog_intensity=0.7.

Pratik mimari iki katmandan oluşur. Birinci katman editor-time AI'dır: Claude, GPT veya Gemini gibi LLM'ler bir HTTP endpoint üzerinden tasarımcının prompt'unu alır ve JSON formatında parametre tablosu döner. UE5 tarafında bu JSON, PCG grafiğine attribute set olarak beslenir. İkinci katman runtime curation'dır: oyuncu davranışını izleyen küçük transformer modelleri, level'a giren her oyuncu için PCG parametrelerini hafifçe modüle eder; örneğin oyuncu çok yorgun gözüküyorsa bir sonraki encounter daha sönük üretilir.

Bu yaklaşımın iki büyük tuzağı vardır. Birincisi, hallucination: LLM, var olmayan asset isimlerini parametreye yazabilir; PCG grafiğinin bunları silmek için bir defensive layer'ı (asset whitelist) olmalıdır. İkincisi, aesthetic drift: AI çok özgür bırakılırsa oyunun sanat yönü dağılır. Çözüm, AI çıktısını her zaman küçük bir parametre uzayına (5-10 değişken, sınırlı min/max aralık) hapsetmektir. AI'ı, sınırsız tasarımcı değil, hızlı bir prop yerleştirici asistan olarak konumlandırın.

Somut bir prompt örneği: "NightRecord apartmanının 3. kat 7 numaralı dairesi. Sahibi 60'lı yaşlarda emekli bir öğretmen, eşi geçtiğimiz yıl vefat etmiş. Salondaki düzen ve clutter seviyesini ayarla." LLM bu girdiden clutter_density=0.3 (dağınık değil, durağan), book_density=0.7 (öğretmenliğin izi), dust_level=0.55 (tek yaşıyor, ama sık temizlik yapmıyor), photo_frame_count=12 üretir. PCG grafiği aynı asset setinden bambaşka bir daire kurar.

İndie Kullanım Senaryoları: Doğru Yer ve Yanlış Yer

PCG'nin en sık yapılan hatası, "her yere kullanılabilir" sanılmasıdır. Aslında PCG'nin doğru kullanımı için bir karar matrisi vardır. Doğru yerler şunlardır:

  • Açık dünya streaming dekorasyonu: World Partition ile birlikte, her cell yüklendiğinde o cell'in biome'una göre flora, taş ve clutter üretmek. Bu, en doğal PCG senaryosudur.
  • Roguelike level generation: Her run'da farklı dungeon, farklı oda dizilişi. Bu, klasik PCG kullanımıdır ve oyuncuya kalıcı yenilik hissi verir.
  • Environmental dressing: Hand-placed ana sahnenin üzerine prosedürel olarak konan küçük detaylar; tozlar, yaprak yığınları, kâğıt parçaları, küçük taşlar.
  • Variation factory: 50 farklı sandık, 80 farklı kitap rafı, 30 farklı masa ihtiyacınız varsa; PCG ile tek bir grafiği parametre vererek 50 varyant üretebilirsiniz.

Yanlış yerler de en az bunlar kadar önemli:

  • Ana hikâye sahneleri: Oyuncunun önemli bir kararı vereceği oda, asla PCG ile üretilmemelidir. Hand-place edin, her bir prop'un duygusal anlamı olsun.
  • Boss arenaları: Combat arenası prosedürel olamaz; sightline ve cover dengesi PCG'nin random'una bırakılırsa savaş bozulur.
  • Tutorial alanları: İlk 30 dakikalık oyun deneyimi, oyuncunun motoru anlamasıdır; PCG'nin getirdiği belirsizlik burada öğrenmeyi sabote eder.
  • Karakterler ve narrative props: Hikâye taşıyan objeler (mektuplar, fotoğraflar, anahtar eşyalar) prosedürel asla olmamalıdır.

Pratik Bir Mini-Pipeline: Apartman İçi Detay Yerleştirme

Şimdi soyut konuştuğumuz her şeyi somutlaştıralım. NightRecord: Thin Walls'da her bir daire farklı bir hikâye taşır; bu hikâyeyi hand-place ile yapmak 30 daire için 30 hafta demektir. Bizim çözümümüz şudur: ana mobilya (yatak, masa, dolap) hand-placed; geri kalan her şey — kitaplar, fotoğraflar, kâğıtlar, kupalar, tozun nereye yığıldığı — PCG ile.

Pipeline beş katmandan oluşuyor. Birinci katman: Apartment Profile, bir DataAsset'tir; her daire için sahibi, yaş aralığı, meslek, son olay (eş kaybı, çocuk taşındı, yeni evlendi, vb.) tutar. İkinci katman: LLM Bridge, bu profili JSON olarak Claude API'ye gönderip parametre seti döndürür. Üçüncü katman: PCG Graph, parametre setini attribute set olarak alır. Dördüncü katman: Surface Sampler, dairenin yatay yüzeylerinden (masa üstü, raf, döşeme) point dağılımı üretir. Beşinci katman: Asset Picker, parametrelere göre prop seçer ve yerleştirir.

Somut bir örnek: 7. dairenin emekli öğretmeninin salonu. LLM book_density=0.7 verir; Surface Sampler kitap rafı yüzeyinde 40 nokta üretir; Weighted Random Pick kitap mesh setinden (akademik, roman, ansiklopedi) ağırlıklı seçer; sonuçta raf 24 kitapla doldurulur. Aynı grafik 12. dairenin yeni evli çiftine uygulandığında book_density=0.15 üretir ve raf sadece 4-5 kitap içerir. Aynı motor, bambaşka hikâye.

Tozlar için ayrı bir alt-grafik var. dust_level parametresi, her yatay yüzey üzerinde transparent decal density'sini sürer; toz, yüzeyin köşelerine yakın daha yoğun, ortasına yakın daha seyrek dağılır (kullanım izini taklit etmek için). 60+ yaş profilinde toz biraz daha yoğun, ama clutter düşük. 30 yaş profilinde tam tersi. Bu, oyuncunun farkında olmadan algıladığı katmandır ve environmental storytelling'in özüdür.

Pipeline'ın son hassas noktası, regenerate determinism'dir. Aynı seed ve aynı profile'la grafik her zaman aynı sonucu üretmelidir; aksi halde QA imkansızlaşır. PCG'nin Seed input'u apartmanın internal ID'sine bağlanır; oyun versionları arası tutarlılık böylece korunur.

Sıkça Sorulan Sorular

PCG plugin UE5'in hangi sürümünde stable oldu?

PCG Framework, UE5.2 ile birlikte experimental olarak tanıtıldı, UE5.3 sürümünde production-ready statüsüne yaklaştı ve UE5.4 ile birlikte stable olarak işaretlendi. UE5.4 sürümünden itibaren node grafiklerini büyük projelerde güvenle kullanabilirsiniz. UE5.5 ile gelen runtime generation özellikleri sayesinde streaming dünyaları da PCG ile dinamik olarak üretebiliyorsunuz. Eski sürümlerde plugin'i kullanmak isteyen ekiplerin Editör'den 'Plugins → PCG' yolundan manuel olarak etkinleştirmesi gerekir. Resmi dokümantasyon için Epic'in PCG Overview sayfası başvurulacak kaynaktır.

PCG runtime mu yoksa build-time mı çalışır?

PCG her iki modu da destekler. Çoğu indie ekip için sweet spot build-time generation'dır: Editör içinde grafik yürütülür, sonuçlar level'a Static Mesh Instance olarak gömülür, pakete derlendiğinde performans cost'u yalnızca normal ISM/HISM render'ından ibarettir. Runtime generation modunda ise grafik World Partition cell'i yüklendiğinde tetiklenir; bu sınırsız oyun dünyaları için güçlüdür ama tasarım maliyetini ve frame-time riskini ciddi şekilde artırır. NightRecord: Thin Walls'da apartman içi detayları build-time, açık dış alanları runtime karışımıyla üretiyoruz.

Houdini Engine indie ekipler için pahalı mı?

Houdini'nin Indie lisansı yıllık ortalama 269 USD seviyesindedir ve son satılan oyunun yıllık gelir tavanı 100.000 USD'ye kadar olan ekipler için kullanılabilir. Houdini Engine entegrasyonu bu pakete dahildir. Bu fiyatlandırma, profesyonel sürümün on binlerce dolarlık etiketine kıyasla küçük stüdyolar için erişilebilirdir. Yine de Houdini'nin asıl maliyeti lisans değil öğrenme eğrisidir: HDA (Houdini Digital Asset) kurmak ve UE5'e bağlamak haftalar süren bir disiplin gerektirir. UE5 PCG plugin'i çoğu indie senaryosu için yeterlidir.

AI tabanlı PCG hangi araçlarla yapılabilir?

2026 itibarıyla AI tabanlı PCG iki katmandan oluşur. Editör tarafında LLM API'leri (Claude, GPT, Gemini) tasarımcının doğal dil prompt'larını PCG parametrelerine çeviren bir köprü olarak kullanılır; örneğin "çürümüş bir bataklık köyü" isteği, density, biome ID, prop set ve clutter level değerlerine map edilir. Runtime tarafında ise hafif transformer modelleri level düzeyinde varyasyon üretir; Wavefunction Collapse ve grammar-based sistemler hâlâ predictable sonuç gerektiğinde tercih edilir. AI'ın PCG için en güvenli kullanımı, parametreleri öneren bir asistan olarak konumlandırılmasıdır.

PCG ile yapılmış dünya tekrar tekrar aynı mı görünür?

Doğru tasarlanmadığında evet, görünür. Bu sorun "procedural sameness" olarak adlandırılır ve tek bir asset set ile dağıtım yapılan grafiklerde kaçınılmazdır. Çözüm üç katmanlıdır: birincisi, prop variation sayısını artırmak (her arketip için en az 5-8 mesh varyasyonu); ikincisi, biome boundary'lerini yumuşatan blend noise'lar kullanmak; üçüncüsü ve en önemlisi, kritik anlarda hand-placed override'lar eklemek. PCG'yi "her yere koy" aracı değil, "sıkıcı yerleri doldur" aracı olarak düşünmek daha sağlıklıdır.

Sonuç: Hibrit Felsefe

Bizim Althera Games olarak PCG'ye bakışımız tek cümleyle özetlenebilir: elle yapılmış ana sahne, prosedürel detay katmanı. Bir oyuncuyu bir odaya getiren yol, o odada nereye bakacağı, hangi prop'u eline alacağı; bunlar elle tasarlanmış kararlardır. Ama o odadaki 80 küçük detay, tozun yığıldığı köşeler, rafa istiflenmiş kitapların hangileri olduğu; bunlar PCG'nin alanıdır.

AI katmanı bu yaklaşımı yeni bir seviyeye taşıyor. Tasarımcı artık "şu dairenin sahibi 60 yaşında bir öğretmen" diyor ve sahne kendini kuruyor. Bu, tasarımcının üzerinden mekanik yükü alır ve niyet düzeyinde karar vermeye yönlendirir. PCG hakkında konuşurken aslında konuştuğumuz, ekibin yaratıcı dikkatinin nereye akacağıdır.

Bu yazıyı tamamlayan sister okumalar için World Partition rehberimiz ve Nanite rehberimiz doğal başlangıç noktaları; VFX katmanı için ise Niagara VFX rehberimiz ilgi çekici olabilir. Apartmanın her dairesinde farklı ama her zaman "doğru" hissettiren ufak detayların ardındaki PCG mantığını NightRecord: Thin Walls'da göreceksiniz. Oyun sayfamıza uğrayın.

Procedural Content Generation with AI: Building Infinite Worlds in UE5

TL;DR

  • • PCG is a procedural placement system that runs at both build-time and runtime; a single graph absorbs tens of hours of manual decoration work.
  • • The UE5 PCG plugin is built on a node graph, point sets, and spline logic; attribute sets carry per-point metadata throughout.
  • • An AI layer bridges LLM prompts to PCG parameters or biome design; it translates a designer's language into numbers.
  • • Houdini Engine is the gold standard for pro-grade procedural geometry; native UE5 PCG is enough for most indie scenarios.
  • • The indie sweet spot is hand-crafted main scenes plus a procedural detail layer; treat PCG as a "fill the boring spots" tool, not a "place everything everywhere" tool.

Procedural Content Generation (PCG) is the practice of building game worlds by rules rather than by hand. A single graph, a single noise function, a single attribute table can produce tens of kilometers of forest or the interior detail of hundreds of apartments. In 2026, when this practice marries an AI-driven prompt layer, the mechanical decision burden lifts off the designer entirely.

At Althera Games, we use PCG to build both the workshop full of dozens of ingredient piles in Potion Rise Simulator and the lived-in feel of every single apartment in NightRecord: Thin Walls. In this article we'll cover how the UE5 PCG plugin works, where AI fits in, and the correct limits for indie teams. For a wider engine overview, our UE5 indie development guide is a useful companion piece.

What Is Procedural Content Generation, and Why It Matters in 2026

PCG is not a new concept in game development history. In the late 1980s Rogue and NetHack regenerated dungeon maps on every session. In 1996 Diablo popularized the random-dungeon logic that founded modern action-RPGs. Minecraft (2009) carried Perlin-noise-driven biome generation into the mainstream. No Man's Sky (2016) demonstrated a "star-scale" PCG system capable of producing 18 quintillion planets from a single seed. On top of that legacy, PCG today is not a game mechanic; it is a pipeline decision.

Three forces shape the PCG landscape in 2026. First, the engine-side tooling has matured: the UE5 PCG Framework, Houdini Engine, and Unity's traditional ProBuilder + custom scripts combination. Second, open worlds have become a permanent norm; from Hogwarts Legacy to Cyberpunk 2077: Phantom Liberty, every major release leans on PCG as the invisible assistant carrying the decoration load. Third, AI-driven content generation has entered the pipeline; designers no longer hand-tune every parameter, they state intent in a sentence and the system adapts.

For indie teams the practical translation is clear: a two- or three-person studio trying to hand-build a 50-hour game world without PCG would burn a full person-year just on decoration. With PCG, the same job, once decisions rise to the archetype level, collapses to weeks. The real subject of this article is how to do that without losing quality.

The UE5 PCG Plugin: Graph, Points, and Splines

The UE5 PCG Framework is a node-graph procedural system introduced as experimental in UE5.2 and marked stable in UE5.4. Its mental model is built around three concepts: point, spline, and attribute set. Each point represents a world transform plus its bound metadata (density, scale, color, biome ID, and so on). A graph produces points, filters them, transforms them, and at the end stamps them into the scene as Static Mesh Instances.

A typical forest-scatter graph flows like this: Get Actor Data pulls the terrain in as a volume, Surface Sampler generates a noise-driven point distribution, Density Filter drops points below a threshold, Transform Points applies random rotation and scale, and finally Static Mesh Spawner stamps the meshes into the scene. The whole chain lives inside a single PCG Volume, and moving the volume re-evaluates the graph automatically.

Spline-based generation is for lining up fences along a road, scattering rocks along a riverbank, or placing lamps down a corridor. Points sampled from a spline are enriched with attribute sets; point density can drop as you near the spline's tail, for example. Attribute sets are PCG's real strength: every point carries a table of data, and you can use that data downstream as a condition. For debugging, the Debug node and the Inspect view show point clouds and attribute values live in the PCG Editor.

PCG + Lumen + Nanite: The Performance Story

The biggest illusion PCG creates is that it is "free". In reality, PCG affects runtime performance through three channels: generation cost (graph execution time), memory footprint (the weight of generated mesh instances), and render cost (the triangles drawn every frame). The pragmatic strategy for indie teams is to push generation cost to build time and manage render cost with Nanite plus ISM/HISM.

In build-time generation mode the PCG graph runs in the Editor, the results bake into ISMComponent and HISMComponent data, and in the packaged build you pay only the instance render cost. This is the safest path for predictable performance. Runtime generation triggers when a World Partition cell loads; it is powerful for endless worlds but carries the risk of millisecond-scale hiccups at each cell load. r.PCG.RuntimeGeneration.Async 1 enables asynchronous execution; shipping to production without that flag set is risky on complex graphs.

The HISM-vs-Nanite decision is another critical point. Nanite is the geometry system that auto-LODs meshes with millions of triangles; combined with PCG it makes "infinitely detailed" scenes feasible. But Nanite is not ideal for many small or moving meshes; for grass, small rocks, and tiny leaves in the thousands, classic HISM is still faster. In our Potion Rise Simulator workshop, large shelves and wall panels are Nanite while the hundreds of small bottles on the table use HISM.

The cost of PCG is not in executing the graph but in how the resulting scene is drawn. Assuming PCG is "free" without a profiler pass is the most expensive illusion a team can carry.

For profiling, the triad stat PCG, stat InstancedStaticMeshComponent, and Unreal Insights → PCG Trace is essential. When working alongside Lumen, make sure PCG-spawned meshes are correctly registered to the surface cache; otherwise the scene will produce inconsistent indirect lighting.

Houdini Engine Integration: The Pro Pipeline

Native UE5 PCG covers roughly 80 percent of indie scenarios. The remaining 20 percent, especially terrain sculpting, destruction, complex spline networks (road and river systems), and parametric architecture (procedural buildings), still belong to SideFX Houdini, the industry gold standard. Houdini Engine lets you package a Houdini project as an HDA (Houdini Digital Asset) and run it inside UE5 as a parametric node.

An HDA hands the designer's Houdini graph to UE5 as a black box: in the UE5 scene the designer feeds the HDA a spline and a set of parameters, Houdini processes them, and the result returns to UE5. The real strength of this pipeline is everything Houdini's VEX scripts and simulation nodes can do that native UE5 PCG cannot: realistic rock weathering, correct hydrological flow placement of rivers, generating a city's street network with Wavefunction Collapse.

On licensing: Houdini's Indie tier sits at around 269 USD per year and is available for teams whose last yearly revenue stays below 100,000 USD; Houdini Engine integration is part of the package. The pro tier comes with a tens-of-thousands tag. The full license terms are at the SideFX Houdini Engine page.

Decision matrix: if no one on your team knows Houdini, start with native UE5 PCG. If you genuinely need procedural terrain or parametric architecture and your team can spend weeks learning Houdini, the HDA pipeline pays serious long-term dividends. In NightRecord: Thin Walls we produce the core apartment modules with native UE5 PCG and the urban-fabric details around the Soviet block with a small set of Houdini HDAs.

The AI Layer: LLM-Driven Biomes and Scenarios

As of 2026, the most exciting layer added on top of PCG is AI-driven parameter generation. This does not mean "let AI build the whole world"; on the contrary, AI here is an assistant holding the PCG control panel. The designer writes "a rotted swamp village, boat docks, broken lanterns" in natural language; the LLM translates that into the PCG graph's parameter set: biome_id=swamp_decay, density=0.6, prop_set=village_ruined, moisture=0.85, fog_intensity=0.7.

The practical architecture sits on two layers. The first is editor-time AI: an LLM such as Claude, GPT, or Gemini takes the designer's prompt via an HTTP endpoint and returns a JSON parameter table. On the UE5 side, that JSON feeds into the PCG graph as an attribute set. The second is runtime curation: lightweight transformer models that observe player behavior modulate the PCG parameters for each player entering a level; if the player looks worn out, the next encounter generates more sparsely.

Two large pitfalls. First, hallucination: the LLM can write asset names that do not exist into a parameter; the PCG graph needs a defensive layer (an asset whitelist) to silently drop these. Second, aesthetic drift: too much freedom and the game's art direction dissolves. The fix is to lock AI output into a small parameter space (5 to 10 variables, hard min/max ranges). Frame AI not as an unbounded designer but as a fast prop placement assistant.

A concrete prompt example: "NightRecord apartment 3rd floor unit 7. Owner: retired teacher in her 60s, husband passed last year. Tune living room order and clutter." The LLM produces clutter_density=0.3 (settled, not messy), book_density=0.7 (a teacher's residue), dust_level=0.55 (lives alone, cleans irregularly), photo_frame_count=12. The PCG graph builds a completely different flat from the same asset set.

Indie Use Cases: Right Spots and Wrong Spots

The most common PCG mistake is assuming it belongs everywhere. The right usage actually follows a decision matrix. The right spots are:

  • Open-world streaming dressing: with World Partition, produce flora, rocks, and clutter per cell based on its biome when it loads. This is the most natural PCG scenario.
  • Roguelike level generation: different dungeon, different room layout every run. The classic PCG use case, giving the player a permanent sense of novelty.
  • Environmental dressing: small details laid on top of a hand-placed main scene; dust, leaf piles, paper scraps, small rocks.
  • Variation factory: if you need 50 different chests, 80 different bookshelves, or 30 different desks, a single PCG graph driven by parameters produces 50 variants from one template.

The wrong spots are equally important:

  • Main story scenes: the room in which the player makes a meaningful choice should never be procedural. Hand-place it; let every prop carry emotional weight.
  • Boss arenas: combat arenas cannot be procedural; sightline and cover balance breaks the moment PCG's random rolls touch them.
  • Tutorial spaces: the first 30 minutes of play is the player learning the engine; PCG's uncertainty sabotages that learning.
  • Characters and narrative props: any object that carries story (letters, photographs, key items) must never be procedural.

A Practical Mini-Pipeline: Apartment Interior Detail Placement

Now let's make everything we discussed concrete. In NightRecord: Thin Walls every flat carries a different story; doing that by hand for 30 flats means 30 weeks of work. Our solution: main furniture (bed, table, wardrobe) is hand-placed; everything else, the books, the photographs, the papers, the cups, the corners where dust collects, is driven by PCG.

The pipeline has five layers. Layer one: Apartment Profile, a DataAsset that tracks owner, age range, profession, recent event (spouse loss, child moved out, newlyweds, and so on) for each flat. Layer two: LLM Bridge sends the profile as JSON to the Claude API and returns a parameter set. Layer three: PCG Graph accepts the parameter set as an attribute set. Layer four: Surface Sampler distributes points across the flat's horizontal surfaces (tables, shelves, floor). Layer five: Asset Picker chooses props based on the parameters and places them.

A concrete case: the retired teacher's living room in unit 7. The LLM returns book_density=0.7; Surface Sampler produces 40 points on the bookshelf surface; Weighted Random Pick draws weighted from the book mesh set (academic, novel, encyclopedia); the shelf fills with 24 books. The same graph applied to the newlywed couple in unit 12 produces book_density=0.15 and the shelf holds only 4 to 5 books. Same engine, completely different story.

Dust has its own subgraph. The dust_level parameter drives transparent decal density on every horizontal surface; dust pools more densely toward the edges of a surface, more sparsely toward the center, to mimic use patterns. In a 60+ profile dust is slightly heavier, clutter lower. In a 30-something profile, the opposite. This is the layer the player perceives without realizing, and it is the core of environmental storytelling.

The final delicate point in the pipeline is regenerate determinism. The same seed and same profile must produce the same result every time; QA becomes impossible otherwise. The PCG Seed input is bound to the flat's internal ID; cross-version consistency is preserved that way.

Frequently Asked Questions

Which UE5 version made the PCG plugin stable?

The PCG Framework was introduced as experimental in UE5.2, approached production-ready status in UE5.3, and was marked as stable in UE5.4. From UE5.4 onward you can safely use node graphs in large-scale projects. UE5.5's runtime generation features make it possible to produce streaming worlds dynamically with PCG. Teams on older versions need to enable the plugin manually through "Plugins → PCG" in the Editor. The official reference is Epic's PCG Overview page.

Does PCG run at runtime or build-time?

PCG supports both modes. The sweet spot for most indie teams is build-time generation: the graph runs inside the Editor, the results bake into the level as Static Mesh Instances, and at package time the cost collapses to ordinary ISM/HISM rendering. In runtime generation mode the graph fires when a World Partition cell loads; that is powerful for endless worlds but raises design cost and frame-time risk significantly. In NightRecord: Thin Walls we build apartment interiors at build-time and mix outdoor zones with runtime PCG.

Is Houdini Engine too expensive for indie teams?

Houdini's Indie license sits around 269 USD per year and is available to teams whose last shipped game grossed under 100,000 USD per year. Houdini Engine integration is included in that package. Compared with the tens of thousands of dollars the professional tier costs, it is genuinely accessible for small studios. The real cost is not licensing but the learning curve: setting up an HDA (Houdini Digital Asset) and binding it to UE5 takes weeks of dedicated discipline. The native UE5 PCG plugin is enough for most indie scenarios.

Which tools enable AI-driven PCG today?

As of 2026, AI-driven PCG sits on two layers. On the editor side, LLM APIs (Claude, GPT, Gemini) serve as a bridge that translates a designer's natural-language prompts into PCG parameters; a request for "a rotted swamp village", for example, maps to density, biome ID, prop sets, and clutter levels. On the runtime side, lightweight transformer models drive level-grade variation; Wavefunction Collapse and grammar-based systems remain preferred where predictability is required. The safest framing for AI in PCG is as an assistant suggesting parameters, not the author of the geometry itself.

Do PCG worlds look repetitive over time?

If poorly designed, yes. The problem is called "procedural sameness" and is unavoidable in graphs that ship with a single asset set. The fix has three layers: increase prop variation count (at least 5 to 8 mesh variants per archetype); soften biome boundaries with blend noise; and most importantly, add hand-placed overrides at key moments. Treating PCG as a "fill the boring spots" tool rather than a "place everything everywhere" tool is far healthier.

Conclusion: A Hybrid Philosophy

Althera Games' view on PCG fits in one line: hand-crafted main scenes, procedural detail layers. The path that brings the player into a room, what they look at first in that room, which prop they pick up; those are hand-designed decisions. But the 80 small details in that room, the corners where dust gathers, which books are stacked on which shelf; those belong to PCG.

The AI layer takes this approach to a new level. The designer now says "this flat's owner is a 60-year-old teacher" and the scene assembles itself. That removes the mechanical load from the designer and pushes them up to decision-level intent. When we talk about PCG, what we're really talking about is where the team's creative attention flows.

Natural companion reads to this article are our World Partition guide and Nanite guide; for the VFX layer, our Niagara VFX guide is also relevant. You'll see the PCG logic behind apartments where every flat feels different yet always "right" in NightRecord: Thin Walls. Visit our games page when you're ready.

UE5 PCG AI / LLM Houdini Engine Indie Dev Procedural Generation

Apartmanın her dairesinde farklı ama her zaman "doğru" hissettiren ufak detayların ardındaki PCG mantığını NightRecord: Thin Walls'da göreceksiniz. Steam'de wishlist'e ekleyin.

You'll see the PCG logic behind apartments where every flat feels different yet always "right" in NightRecord: Thin Walls. Wishlist on Steam.

Steam Wishlist

İlgili Yazılar Related Posts

Geliştirme / Development
UE5 World Partition Rehberi UE5 World Partition Guide
Geliştirme / Development
Nanite Rehberi: UE5 Sınırsız Geometri Nanite Explained: Unlimited Geometry in UE5
Geliştirme / Development
Niagara VFX Rehberi Niagara VFX Guide