Edmond Ho


Nimbus is a proof-of-concept for a lightweight cloud rendering engine. The downloadable demo shows a single cloud throughout the day, passing through sunrise, daytime, sunset and nighttime.

Though unfinished as of 2006, the Nimbus engine is capable of rendering realistic-looking clouds. The cloud shown in the demo was created in about two hours by a programmer who’s not great at computer art. Most of that time was spent manually editing colors in the cloud and light definition files. In the hands of a talented artist and with some better tools, even better looking clouds can be rendered in the current Nimbus engine.

Cloud rendering in Nimbus is based on a method used by Microsoft Flight Simulator 2004: A Century of Flight, which is described in a paper by developer Niniane Wang. Briefly described, this method models clouds as particle systems of billboarded sprites. Realistic lighting is approximated using a combination of simulated ambient light and directional light. Ambient lighting is defined as a range of colors over a range of heights in the cloud. Directional lighting is defined as a range of colors that are mapped onto the cloud depending on the direction of the light source to the cloud.

This method has several advantages and disadvantages. First, since clouds are created manually, not programatically, it’s easier to create good-looking clouds. With a cloud generating algorithm, it's typically harder to directly and intuitively manipulate the models. However, manually creating clouds takes time and talent.

Second, the lighting approximation is simple compared to more physically accurate lighting simulations, resulting in good performance without sacrificing visual quality. However, this simple lighting approximation does have some visual inaccuracies and limitations, such as a lack of cloud self-shadowing.

Nimbus was originally envisioned as an unconventional puzzle game, in the spiritual vein of unusual games like Katamari Damacy. Players would control clouds via mouse gestures. Clouds could be combined and would create rain when large enough. The rain would then cause plants to grow on the ground below. Clouds would also shield plants from too much sunlight, which would wilt the plants otherwise. Nimbus would have no measurable objectives and would be slow-paced, hopefully evoking a sort of Zen rock garden mentality. Players would simply make pleasing landscapes.

In the future, I’d like to add cloud movement and evolution to the Nimbus engine. Currently, clouds are static shapes and do not move across the sky. Allowing clouds to change shape as they move across the sky would dramatically increase the realism, and is a feature critically necessary to the finished Nimbus game. Another issue that needs to be resolved is a bug in the current engine that causes the demo to unexpectedly crash.



To see Nimbus in action, first download the Nimbus installer. Next, install the demo by running the “NimbusInstaller.exe” file. The installer is a self-extracting ZIP file that will create a directory named “Nimbus”. Run the “Nimbus.exe” file in this directory to see the demo. To uninstall the demo, simply delete the “Nimbus” directory.

Nimbus was developed on a computer with the following system specifications, and should run fine on any similar computers:

  • Windows XP
  • Radeon 9700 Pro
  • Pentium IV 2.8 GHz
  • 512 MB RAM

Download the Nimbus installer.

Source Code

For the curious, the complete source code for Nimbus is available for evaulation. Please do not modify or redistribute the source code, in part or in whole, without permission. The source code is packaged as a ZIP file.

Nimbus was developed in C++, using OpenGL and SDL.

Download the Nimbus source code.


Nimbus Cloud Creator, a Blender plug-in.

Like the Microsoft Flight Simulator 2004 team, I developed a plug-in for a 3D modeling program to help artists create cloud models for Nimbus. After all, manually specifying vertex coordinates in .cloud files is neither fun nor productive.

The Nimbus Cloud Creator is plug-in for Blender, the popular open-source 3D modeling program. The plug-in is a Python script that uses functionality exposed by the Blender API.

To use the plug-in, first install Blender. Next, download the script and save it to some convenient directory. Then in Blender, open the “NimbusCloudCreator.py” script in a text window and press “Alt+P” to run the script.

Artists broadly define a cloud’s shape using overlapping boxes. The Cloud Creator will randomly generate particles within that volume when the “Create Cloud” button is pressed. The randomly generated particles are created within the parameters set in the cluster of buttons at the top of the script: the number of particles, the particle size range, and the particle rotation range.

The Cloud Creator also has an interface for defining the color levels and color level sets that are used in the ambient lighting simulation. Color level controls are the group of buttons below the particle controls. Color level set controls are below the color level controls.

Cloud models can be exported to and imported from .cloud files. To export a cloud, select the particles that define the cloud, not including the bounding boxes, and press the “Export Cloud” button. To import a cloud, press the “Import Cloud” button and use the file selection dialog.

There are some known issues that may be resolved in the future:

  • Texture assignment is not supported. Textures default to the included “puff.png” file.
  • The color level set controls are buggy.

Download the Nimbus Cloud Creator plug-in for Blender.

File Syntax

Nimbus has three custom file types that are used to define clouds, light sources and skies: .cloud, .light and .sky. All three file types are loosely based on the common .obj 3D file format and share the same general syntax. These files are plain ASCII text files. Each line in the file defines a particular property and has the following form:

<command> <value 1> ... <value N>

Commands specific to each file type are listed below. A line beginning with a “#” is a comment, and all text following the “#” in the line is disregarded. Examples can be found in the demo, in the “data” directory. Even if you don’t intend to create your own clouds, reading the file syntax will give you a better sense of how cloud rendering works in Nimbus.

.cloud File Syntax

Particles - Clouds in Nimbus are modeled as particle systems of billboarded sprites. That is, particles are textured squares that always face the camera. Information for each particle, such as position, is stored in .cloud files using the following command:

p <x> <y> <z> <rotation> <radius> <texture file>

Particle definitions begin with a “p”. This is followed by the x-, y-, and z-coordinates of the particle, which are floating-point numbers. Next is the particle rotation angle, specified in degrees as a floating-point number. Next is the radius of the particle, as a floating-point number. Finally, the path to the texture file relative to the location of “Nimbus.exe” is specified. Multiple particle definitions are allowed.

Color levels - The ambient lighting simulation in Nimbus is based on color levels, which are mappings of colors to a specific height within a cloud. Particles above a certain height are rendered with the appropriate color. Multiple color levels are used to build a convincing cloud color. For example, a fair weather cloud may be light gray on the bottom and white on top.

cl <r> <g> <b> <a> <height>

Color level definitions are begin with “cl”. Next are the red, green, blue, and alpha colors, which are floating-point numbers between 0.0 and 1.0. The last value is the height where particles above have the defined color. The height value is a floating-point number. Multiple color levels are allowed in .cloud files.

Color level sets - Color levels are grouped into color level sets. A color level set associates a time index with a set of color levels that should span the entire height of a cloud. Nimbus interpolates the colors between color level sets over a period of time between the sets’ time indices. This is how ambient light is simulated as changing color throughout the in-game day. Color level set information is stored in .cloud files using the following command:

cls <time> <color level index 1> ... <color level index N>

Color level set definitions begin with “cls”. This is followed by a time index, in milliseconds. The time index is followed by color level indices. A color level index is the position of a color level definition in the file and indices begin counting at zero. For example, if there were two color level definitions in a .cloud file, the index of the first color level would be “0“ and the index of the second color level would be “1”. Color level set definitions can have a variable number of color level indices. Multiple color level sets are allowed in .cloud files.

Cloud properties - Clouds have several properties that affect the entire cloud: birthtime, birthspan, lifespan and death span. The birthtime is the time index when the cloud begins to form. The birthspan is the duration of cloud formation. The lifespan is the duration of the fully formed cloud. The deathspan is the duration of cloud dissipation.

c <birthtime> <birthspan> <lifespan> <deathspan>

Cloud property definitions begin with a “c”. This is followed by the birthtime time index, in milliseconds. Next is the birthspan, in milliseconds. Next is the lifespan, in milliseconds. Next is the deathspan, in milliseconds. Only one cloud properties definition is allowed in .cloud files.

.light File Syntax

Color ranges - Light sources used by Nimbus to simulate directional lighting are defined by a series of color ranges, similar to the color level sets used in the ambient lighting simulation. Color ranges consist of a “minimum” color, a “median” color and a “maximum” color, along with a time index. Particles farthest from the light source get the most directional color contribution from the minimum color; particles clost to the light source get the most directional color contribution from the maximum color.

cr <min r> <min g> <min b> <min a>
<med r> <med g> <med b> <med a>
<max r> <max g> <max b> <max a> <time>

Color range definitions begin with “cr”. This is followed by the minimum red, green, blue, and alpha colors, which are floating-point numbers between 0.0 and 1.0. Next are the median red, green, blue, and alpha colors, which are floating-point numbers between 0.0 and 1.0. Next are the maximum red, green, blue, and alpha colors, which are floating-point numbers between 0.0 and 1.0. The last value is the time index, in milliseconds. Multiple color range definitions are allow in .light files.

.sky File Syntax

Sky properties - Like in the real world, the sky changes color as time progresses. Nimbus interpolates sky colors over a period of time.

s <r> <g> <b> <a> <time>

Sky property definitions begin with an “s”. This is followed by the red, green, blue, and alpha color values, which are floating-point numbers between 0.0. and 1.0. Next is the time index, in milliseconds. Multiple sky properties definitions are allowed in .sky files.


Nimbus was developed in 2006 by Edmond Ho, who was responsible for all of the design, programming, and art. Edmond graduated from Stanford University in 2004 with a B.S. in Computer Science. Edmond is also the developer of a tactical RPG called Tactics Big. Edmond is currently the Directory of Technology and Co-Founder of Ravel Virtual Studios.


Realistic and Fast Cloud Rendering - Microsoft Flight Simulator 2004: A Century of Flight developer Niniane Wang describes a cloud rendering method that Nimbus uses.

Real-Time Cloud Rendering - Mark Harris describes a more detailed and physically accurate cloud lighting simulation, which is demonstrated in his Skyworks engine.

Cloud - A game that is similar in concept to the original idea of Nimbus, but takes a different direction. Cloud was created by a student team at the University of Southern California.

Copyright © 2006 Edmond Ho.