Caromble! is a fresh brick-breaking game in a 3D, physics-based dystopic world with an unique art-style and epic gameplay features you wouldn’t expect in a brick breaker.
It is created by Crimson Owl Studios, a small part time indie team that comes together every Friday to develop their first game. Caromble! will be released in 2015 and will be available on PC, Mac & Linux.

Subscribe and receive Caromble! updates:

Game Development Blog:

The Container Revisited

A simple container-crate was one of the first objects I approached and did tests with to figure out the art style and working approach for Caromble. It has stayed as this, although the game evolved to more of a line-art style over the next years. Time to bring this one up to date.

First, here you can see the original texture I created back then. I tried pencils to draw the details, which gave a nice look in black and white.

pencil texture

The first texture, done with pencil on paper and scanned.

But on the final object, when adding color, it’s actually a bit hard to see. Mostly you would not even get this close. Additionally (and this weighted even more in the decision), it was a lot of work. It’s hard to get the inevitable digital fixes to look exactly like pencil. Imagine cutting and rotating a piece – the parts would not have the same direction of the hatching anymore.

Ingame asset with color

Screenshot from the game, with a color overlay on the texture.

Real-Time colored pencil texure

For better comparison, I’ve made a more up-to date real-time shot of the asset. As you can see – with more effects like reflections and normal map shading, it’s even harder to notice the style.

And here is the updated approach – with just a black pen as base. There is a bit analogue detail in there, like irregularity in the lines, but it’s more subtle and easier to move around.

Generated Pen Texture

The new texture – this time done with Substance Painter, with some tweaks.

In an earlier posting, I described the procedural workflow for these 3D assets. A lot is automated – and then I go over and do manual tweaks. Later the programs help me to create variations like different colors or damaged stages, often with just one or two clicks.

Pen Textured Container

Here is the new version with a texture based on pen line-art. It does have an updated normal map, and the effects, but the line-art shows.

Damaged Container Asset

The damaged version – it’s naturally even more noisy, but still reads as stylized.

Container Color Variations

Furthermore, I generate color variations. Currently as separate textures – though we may switch to a shader that allows the programmers to change the color on the fly.

All objects have this style, with old objects being updated. I have a series of asset-shots on the Caromble blog, to show them off.

The Procedural Texture Workflow

Since I’m solo-arting Caromble!, I have to find ways to optimize the work-flow. In the beginning I did a big degree of the work analog – with pen and paper. But in recent months I’ve set up a very procedurally. Basically keeping the style but letting the computer do the work for me. Here I’ll describe in layman’s terms some steps of how I go about it.

I should first describe what procedural art means. You can think of it as the artist not doing the actual artwork anymore, but describing rules to the computer that it then executes. This has some disadvantages: it takes longer, and needs a different skill set that you have to learn (e.g. knowing how to program is useful). The upside is that you can then just tell the program: Do some more variations. So the more assets you need, the more the initial effort will pay off.

A specific twist in my use-case is that I’m trying to emulate a hand-drawn line style for the textures. Let’s first take a look, of what a final object looks like:

Locomotive Comic Style

Starting out here with the final look of the diesel locomotive, so you see what the target look was. It has a bit of a comic style, but still shading and some little details.

Five years ago, there was not much in usable procedural tools out there. Now tools like Substance Painter became essentially industry standard. A lot of texturing-work you once had to do draw by hand in Photoshop – a tool that was made for … well, editing photos – you get now done near automatically. With Painter you can for example just take a 3D object, and drop a material like “wood” on it, and *boom*, your asset looks like made from wood.

Substance Painter Program Window

A working view of Substance Painter. You can see for example the swaps on the side that I could drag on an object to give it a specific material.

Painter is in essence made for painting details onto the 3D object – so here is the final result I export and then use in our game engine.
For the actual process, the program first calculates various properties of the 3D mesh. These I can then use to create rules – like “where the object has little hidden corners … make it more dark, to simulate shadow”. Notice how this is a flexible process. Depending on the object, I could also say “put dust in these hidden corners”.
Here is the object with this calculated data projected on it – in this case it’s called Occlusion-Map.

Occlusion Map Train

A map that shows shadows on the object, called Occlusion-Map – like how it would get darker in corners. It makes the object more readable.

Another such map shows me the elements of the object. It fills them with flat colors, so that with just a few clicks then I can define unique properties for an element.

Generated Color Code Map

This map automatically color codes elements. This way I can then easily say “make all girders yellow”.

Other examples are a map for showing the thickness of elements:

Generated Thickness Map

For this thickness map, the computer automatically calculates every element that is thin (and becomes black here) or thick (white)

Or the location:

Generated Position Map

The position map is a bit harder to read – but you can see for example, how in one corner everything becomes red. This way you can tell the program for example: “Color everything that’s on the bottom in a certain way”.

Specifically for my use-case, a map showing the edges is useful.


Here is the “Curvature-Map” – it shows edges that point outside as white, and inward pointing ones as black. I used this one as source to create the first step of my texture.

After all, my style has black lines that mimic how in comics elements are separated – which I try to make look like simple ink line style. Using the map you see above, I told the program to automatically draw a black line on all inner and outer edges. Here is the result.

Generated 3D Texture Outline

This outline is completely automatically generated – I told the program to add some distortion, to have more natural look.

It all still needs a more detailed artists input. In the following step, I go in and add by hand all details that the program by itself can not know. Like that locomotives have little lines and exhausts.

Painted 3D outline

I went in and painted in the 3D view, to add specific details like lights.

Using the earlier mentioned Position-Map, I then add variation to the surface.

Generated Damage Train

This step is now automatic – it adds variation. I’m using the height information from the earlier layers, to tell the program: Add more damage at the bottom (as there would be more dirt and such on a train)

I can then easily color it all and export the final result – in this case the flat map with all color details.

Train Texture view

The actual texture in the flat view.

There are some more twists and turns to it all, for example Normal maps. These are nowadays used in all 3D engines, to show the shape of small details on a flat surface. But for sake of brevity I’ll skip some finer points.

Normal Map Generated

The Normal-Map – it shows the 3D engine what 3D shape the smaller elements have.
Again, a lot is automatic – I’ve put for example a wobbly structure on it, to make it seem a bit damaged.

With this result I can use another procedural program, called Substance-Designer. I can then process the export images and create new sizes and color variations with one click.

Substance Designer Program Window

I use Substance Designer to take the base texture and automate the creation of color versions.

Train Generated Colors

These are colors I let Substance Designer create for me.

Another such program is Houdini.

Diesel Train Damage

This is a damaged version, which also includes some distortion of the 3D model, which I do in Houdini

And just as an example, here is a completely different object – but since I could just reuse the rules I’ve set up for the train, most of the result comes for free.

Cabin Generated Texture

It’s a little cabin/exit (kinda like one you would see on a top of a building). It has all the style-elements used for the train, just adapted.

Small Building Colors

Again, thanks to the automation, it’s just one click to get all these color versions.

Procedurally Damaged Building

The damaged version of the building could use the same procedure as the train – with only some adjustments, so that chipped paint for example wouldn’t expose metal, but rather concrete.

Final Commercial Chapter Assets – Part Two

Here are some more of the shiny new versions of the commercial assets.

As shown in the first asset show-off, they all now have a nice default version, a proper damage state and color variations.

Building in Construction

Building in Construction

damaged construction

Damaged construction building.

Colors Construction

Color Variations of the building.

Little extension building

Little extension building

Broken Extension

Broken version

Extension Building Colors

Color variations of the extension.

Apartment block

Apartment block – base version.

Destroyed apartement.

Destroyed version.

Apartment Colors

Apartment colors.

train wagon

Wagon for a train

damaged wagon

Damaged wagon.

colored wagons

Colored wagons

Pedestrain Bridge.

Bridge for Pedestrians.

Bridge Curve.

Curve of the bridge.

Bridge Color Versions

Color versions for the bridges.

Industrial Funnel

And as a special building with no destruction or colors: An industrial funnel.

Commercial Chapter Asset Collection – Part One

Art production for the “Commercial Chapter” of Caromble went to full steam the last months. Most objects were place-holders before, with the fitting shape, but not much details in the 3D meshes and no proper textures. By now all objects have gone though the final process.

I’ve made pictures when I finished an asset, so here is a first collection. One version is always the normal block, the next one is a destroyed version (once the ball has hit the object), and the last is the color variations in an overview).

Building with Trims

Building with Trims

Damage Version

Damaged version of the trimmed Building.

Trimmed Color Versions

Color versions of the trimmed building.


Road with curve.

Road Damaged.

And the damaged road.

Road colors

Road colors.

Fence Cloth

Fence Cloth.

Damaged Fence

Damaged fence.

Fence Colors

Color versions of the fence.

Wood Fence.

A fence made from wood.

Damaged wooden fence.

Damaged wooden fence.

Wood Fence Colors

Wood fence colors.

Brick Wall

A brick wall.

Damaged brick wall

Damaged brick wall.

Brick wall colors

Colors of the brick wall.

Caromble! Friday #404 No pun intended

Even for a stubborn skeptical person such as me it is sometimes hard to deny a certain super-natural tendency in the way things play out. Due to holidays, and the good old ‘huh-is-it-my-turn-again’, we almost didn’t have a Caromble! Friday #404. Page not found… But of course it could also just be that our brains are so hard-wired to find patterns, and perhaps even patterns that don’t exist. My inner skeptic just won’t let me write a paragraph like this without that disclaimer…

Anyway, with the holidays and all, we can perhaps be forgiven for having a bit of a slow week. Weeks do get slow Caromble!-wise easily being part-time developers and all. It just takes a single day of being a bit under the weather, and boom no productivity for a week. Especially in the Holiday season that means that things can get slow quickly.

So what did happen… Well we made some progress in our effort to tell the back story of the game. We got a new version of the storyboard, and are working with that.

Personally I did some work on the planning towards the final release. Deciding on what will fit in the scope of the game is a continuous and difficult process.

As a gamer (which we of course also are) you never know what features, ideas, extra levels and effects didn’t make the cut. You either like or dislike a game. Of course you might have feelings like, ‘this game would be even better with multiplayer’, or great level ideas. But that is not the same as missing a feature. You will definitely notice when a game feels ‘off’ or when it simply isn’t fun. Or when it feels rough and unfinished of course. But when it feels good, but could have been even beter… You just will never know.

As a developer, your game is never finished. There is always one more level to make. Every effect can be made even nice. The balance of the game could always be tweaked a liiitle bit tighter. There might always be another FPS to be gained on a particular system.

So I guess you will always feel like you are releasing something that is in some abstract way unfinished. The witness feels like a perfectly polished game, but who knows how many things Jonathan Blow cut out that we’ll never hear of?

So that is our devil’s dilemma. We want to made a great game. We have been going at it for like 8 or 9 years. But we also want to release it. We have made estimates in the past and gloriously missed them, because there was always something more to add. So I guess it is time to end this cycle and finally decide on when will be done.

Raymond's table


Caromble! Friday #402 Squashing some bugs

As outsiders correctly assume, indie game-development is a big rollercoaster of rock-and-roll awesomeness. And not at all about staying indoors while the weather is nice and fixing bugs. Not at all.

For me, this week’s rock-and-roll awesomeness materialized in the form of euhm several bugs that had to be squashed, while being inside. Hmm.

Anyway, sometimes there is awesome stuff and rollercoasters and rock-and-roll. But today it is bugs. Glorious bug fixing.

It is a well known fact amongst developers that bugs enjoy laughing in your face. However, most of the times you just know that this must be so, without actually being able to see the bug laughing at you. So when I finally encountered a bug that was literally laughing at me, I wasn’t sure what to think.

stop laughing!

The problem was that at a certain point in our Prologue, just before the boss releases a power-up its head would make a jump. Just a small one, but annoying nonetheless. I ‘fixed’ that by always animating the head to a ‘neutral’ position before playing a new animation. However, now I head the problem you can see in the gif. The head would sink before starting the next animation… I figured the reason for that *had* to be that some other animation was also adjusting the position of the head. It had to be. Their effects would combine in some sort of unholy way and cause the sinking effect. Haha, I knew what to do!

It only took me an hour to carefully tracking which animations where affecting the top of the head of our boss at what time. And then another 30 minutes to come to a slow realization that there was no problem with the other animations. No unholy combination of translations. Just a simple oversight on my behalf. I calculated the translation vector for the head to move back to ‘neutral’, and then instead of applying that, I would animate the head towards the animation vector. To the less mathematically inclined, lets just say that makes as much sense as rotating something by a color.

At least by now I understood what that evil bastard was laughing at…

Caromble! Friday #398: Flowing from SVN to Git

Like every other software development team we use version control software to manage changes in our source code and other computer files. For years we have been using Subversion (SVN) as our version control system. In recent times we transitioned to working remotely; as was mentioned in our previous post. Because of this change in the way we work, we figured it’s better to switch to Git as our version control system.


In real life we could sit next to each other for code reviews and working in parallel was easy because communication was easy. Using SVN worked fine. Today, we have to orchestrate this source control workflow a bit more and our experience with Git is that it’s better up for this task. The flow with “branching” (changes that happen in parallel along multiple branches) and “merging” (integrate these changes) feels more natural. See this example of a Git branching and merging workflow (a.k.a. Gitflow) where each node represents a set of changes:

A succesful Git branching model by Vincent Driessen

Source: A successful Git branching model by Vincent Driessen.


We chose GitLab as our Git hosting service because it’s free and it offers a nice web interface, especially for remote code reviews (through the “merge request” feature) to easily manage our changes and keep up the quality of our work.


To migrate from SVN to Git we followed this nice tutorial from Atlassian: Migrate to Git from SVN. It took two days to migrate our Caromble! project, but we’re glad we did this! We’re back in a better flow.

Happy gaming!

Getting the job done is hard. In just three weeks time we’ll celebrate the 400th Caromble! Friday, and we still haven’t finished the game yet. Admittedly, we are not 100% clear when the first Caromble! Friday was exaclty, but 400 probably isn’t that far of the mark.

As some of you are aware, a lot of things have changed in the personal lifes of several of our team members recently (suddenly there are 3 fathers in our team 🙂 ), and those changes are not without their impact on the way we work.

We have effectively moved from a team that worked together in a single location (ok, the office was actually a kitchen table, but that still counts), from a team that has to work completely remote. And on unpredictable hours as well. That is not necessarily an easy transition.

A lot of things that we got for ‘free’ by being in the same room every Friday are now quite hard. For instance getting time for all the chit-chat that is so essential for productive co-operation is suddenly a thing you have to plan. And the same goes for discussing the little questions you might have when developing.

But things are not fun if they are not challenging, so we are happy to embrace all of this unplanned extra fun ;-).

We are making a lot of changes to the way we work, so that we may stay productive and at the same time still have fun while working on the game.

We try and use productivity tools such as Trello and Gitlab where we can. These tools can greatly structure the discussions you have about various topics. It turns out that Slack is also quite useful, and whatsapp maybe not so much.

Another thing that we cannot delay any further is creating a marketing plan to guide us through the final stages of development towards the final release.

So indeed, while we have not produced as much visible output as we wanted to at this point, we are still very busy with the game.

To conclude this post, I have two images. Of course an image can be worth a 1000 words, but the first image I’ll share will communicate at least two messages:

Getting the job done, and also defender

The first message is of course that Defender will be a new awesome skill level to be included with our next release. And the second one is less literal and shows that we’ll always eventually get the job done.

Ok, and my second image is perhaps a bit cheesy (cheesecake?), especially since I’m not exactly immune to spelling mistakes myself, but still, I could simply not resist making a bit of fun about Peter’s spelling mistake in his last post, and showing an image about some actual peace of cake…

An actual peace of cake...

Follow and read our updates on Steam!

Dearest Caromblers!

As you probaby already know, Caromble! is available on Steam Early Access! Instead of updating 2 blogs, we have decided to post all of our development updates on the Steam announcements. We hope to see you there!

We would like end to this blog site with an interview that Thomas D. and Raymond gave in London at PC Gamer Weekender. You can find us again in London next week at EGX Rezzed.

Enjoy this video and enjoy Caromble! 🙂


Caromble at PC Gamer Weekender 2017!

Well in fact only Raymond is larger than life, or at least taller. I (Thomas D) think I’m only just about life sized.

The paddle has landed and the PC Gamer Weekender ball is rolling in Londen. Raymond and I have taken our positions at our booth and will be looking to show [i]Caromble![/i] to as many people as we can.

Caromble  on PC Gamer Weekender 2017

We are looking forward to seeing you as well! Come find us at booth E20. And very hush-hush: we might be selling the game at a discount from our booth.

Caromble  on PC Gamer Weekender 2017