Setting Up Your Pipeline for City Of Dreams Nightmare
I've been working with this for about two years now, mostly after the official tooling release came out in late 2023. The short version: it's a rendering and compositing pipeline built for photorealistic city environments, and it ships with a bunch of node-based shaders that are decent but not great out of the box. The long version is that you'll spend the first week just debugging texture resolution mismatches before anything actually looks correct. Here's how I actually got it running. First, grab the build from the official GitHub mirror — the one tagged v2.1.4-nightly. Don't use the latest commit. The nightly builds have a dependency conflict with the newer versions of the render backend that nobody bothered fixing. v2.1.4 is stable enough that I haven't had a crash in six months. Installation is straightforward if you follow the README exactly. Clone the repo, run npm install, then npm run build:production. That last step takes about twelve minutes on a decent machine. If you try to skip it and run from source, the path resolution for the asset libraries breaks. I learned that the hard way on a Tuesday afternoon.
The config file lives at ~/.dreams/config.json. You'll want to edit this before your first render. The default settings assume you're running on a Linux server with a Quadro GPU. If you're on a consumer card like an RTX 4090, change the render_backend field to cuda_12 and set memory_limit_mb to 24000. Anything lower and you'll get OOM errors during large scene compiles. I ran into this during a project for a client who wanted a full metro system rendered at 8K. The default config choked at around scene 47.
What Actually Works and What Doesn't
The shader library is the main selling point. It includes materials for concrete, glass, wet asphalt, neon signage, and atmospheric fog. The fog one — atmo_haze_v3 — is genuinely useful. Most people default to the basic fog node and wonder why their distant buildings look flat. Switch to atmo_haze_v3 and set the density to 0.03 with a height falloff of 200. That's the number that works for urban-scale scenes. The LOD system is where most people get stuck. The engine auto-generates level-of-detail meshes based on camera distance, but the threshold values are way too aggressive by default. I found that setting lod_transition_distance to 800 and lod_aggressiveness to 0.4 gives you clean transitions without popping. Below that, the pop-in becomes noticeable even at medium frame rates. Above that, you start wasting VRAM on detail you never see. Here's something the documentation doesn't cover: the ambient_occlusion_pass needs to run before the color_grading_node in your compositor chain. If you reverse the order, the AO gets washed out and your shadows look flat. I discovered this after spending three hours debugging why my night scenes looked like they were shot at noon. The render log will show a warning if the node order is wrong, but it won't stop the render. Just... it'll look wrong. So check the node order. Seriously.
Get the Full Details
Common Pitfalls
Don't use the HDR environment maps that ship with the package. They're low-resolution scans from 2018 and they cause banding on reflective surfaces. I replaced them with my own captures from HDRI Haven and the difference was immediate. The chrome and glass materials in the default package look fine until you compare them side-by-side. The particle system for rain and dust has a hard limit of 50,000 particles per emitter. If your scene needs more, you'll get silent failures — particles just stop appearing. The workaround is to split your emitters across multiple layers and merge them in the final composite. It's messy but it works. I had to do this for a rain scene in a downtown district. Two emitters, each capped at 50K, merged at the output stage. Another thing: the UV unwrapping tool is mediocre. It does a passable job on simple geometry but falls apart on complex facades with lots of windows and details. I ended up writing a small Python script that uses blender-bpy to pre-unwrap building meshes before importing them into the pipeline. Saves maybe twenty minutes per asset, which adds up fast when you're doing a whole city block.
When to Walk Away
This tool is not a good choice if you need real-time interactivity. It's a batch renderer. There's no viewport, no live feedback. You set up a scene, hit render, and wait. For a small interior, that might be thirty minutes. For a full city block at high resolution, plan on six to eight hours on decent hardware. I've seen people try to use it for interactive visualization and they end up frustrated because it was never designed for that. If you need real-time performance, look at Unreal Engine 5 with Nanite and Lumen instead. It handles the same urban scenes in a fraction of the time and you get a proper viewport. The tradeoff is that the photorealism isn't quite at the same level for still renders, but for anything that requires interactivity, it's the better path. The City Of Dreams Nightmare pipeline also doesn't support VR export natively. There's a community plugin for it but it's unstable and hasn't been updated in over a year. I tried using it on a project and ended up fixing three crashes manually in the source code. Not worth it unless you have the time.
Final Notes
Keep your GPU drivers updated. The cuda_12 backend is sensitive to driver versions. I had a render fail because I was on an older driver that didn't support a particular tensor core feature. Updating to the latest studio driver fixed it immediately. Also, back up your config changes. The next update overwrites config.json unless you put your custom config in ~/.dreams/custom_config.json and reference it with the --config flag. I lost a week of tuning once because I didn't know about that. Never again. That's about it. The tool works well once you get past the initial setup friction. Budget extra time for the first project and don't expect it to do everything out of the box. Most of the value is in the configuration and the node chain ordering. Get those right and the renders are solid. Get them wrong and you'll be staring at flat, lifeless images wondering what went wrong.
