Entertainment at it's peak. The news is by your side.

Writing terminal moo: On C++, its ecosystem, performance optimization and more


Here is ready terminal moo.


Fair nowadays I discovered about Block Parts – a purpose of unicode characters that comprise the quadrants (i.e. bottom factual, upper left etc.) of a ‘letter’… all 16 diversifications of these.

That’s clearly a instrument designed to abuse letters as 2×2 pixel fields! From right here on out I’ll consult with these quadrants as pixels. In Windows, a default cmd.exe console window incorporates 120×30 characters which consequence in 240×60 pixels. That’s pretty workable to like some fun. After pretty extra learn I discovered that the windows console added elephantine 24bit color toughen a whereas inspire. And these colors will be purpose for foreground and background individually. So I purpose out to put in writing a puny bit sport.

I’ll spend this pet mission to document on my abilities with issues I encountered. Mostly C++, its associates and performance optimization.

Performance section 1: Colours

Sooner than going head first I needed to make certain that the knowing is sound. It’s abnormal files that console output will be surprisingly late. I became once panicked that this can even salvage an right right-time sport most now now not seemingly. As a transient performance take a look at I filled your total display conceal with varied characters and “rendered” that again and again. That ran very swiftly, no issues yet. Next up: colors. I modified foreground and background colors in rising numbers.

I discovered: Colorful text is now now not late in itself however hundreds color adjustments are:

Nonetheless the upright files is: Even with 3600 color adjustments (that’s foreground and background color commerce for every 2d character), this works at ~60 FPS. So the colors shouldn’t be a yelp-stopper.

Color constraints

Every character on display conceal has a foreground (FG) and a background (BG) color. The character itself will get the FG color, the leisure is BG. When limiting to field ingredients that means in each character you are going to have the option to entirely defend a watch on the geometry of the 2×2 pixels however can handiest spend two colors.

I solved the color limitation with a mannequin that I mediate labored gargantuan. I handled BG and FG graphics otherwise. Within the background I restricted myself to elephantine characters of the identical color, thereby giving up the decision wait on received by the block ingredients.

The foreground objects I handled with elephantine decision, however very restricted color. The excellent shatter consequence of that manner is that there is a lovely straightforward algorithm to take hang of supreme FG and BG colors for every character:

Handle shut one color from the background and the varied from the foreground. Ideally that works out since the color alternative is so restricted there. In instances the put no background will be viewed, I can spend two colors from FG objects.

If there are bigger than two colors in a characters, I try and mitigate the catastrophe by blending colors collectively. That occurs at any time when foreground objects salvage very shut to each varied. That function will be refined in the continuously occurring instances of faint smoke puffs discoloring each varied or varied foreground objects:

It’ll explore harsher with two neatly-organized and late objects. Flying straight over or subsequent to cows or ufos can provoke these system defects:

There’s no supreme design around that limitation in these instances. Restricting the movement to forestall this would in actuality feel fallacious.

Since the background in all fairness low decision, any movement would explore very choppy. To mitigate that I linearly interpolated the background objects horizontally. That makes it explore blurry on the sides then again it’s a take hang of overall thanks to the grand elevated smoothness:

All in all, I in actuality feel adore that labored out pretty neatly. In theory this could per chance per chance per chance also be improved additional. To illustrate the huge majority of the display conceal in total includes honest background. That could be taken wait on of by like a higher-decision mannequin of the background that will get abnormal if unoccluded by any foreground objects, and fallback to the half-res mannequin otherwise.

I had some ache getting the ufo beam to explore fine. Utilizing foreground graphics became once a catastrophe thanks to the color limitations. Utilizing background graphics intended a grand more straightforward function, however the beam of sunshine appears to be like to be like pretty fitting. Nonetheless then you positively’ve gotten got the jam with the Flying saucers being and interesting at twice the decision of the beam function. I designed across the technical limitations: Flying saucers and cow stays quiet when beaming and moreover I make certain that it “parks” at a character-aligned location. And in must the cow interesting upwards, I honest travel it out which labored neatly.

Platform, compiler & libraries

Since I don’t like salvage admission to to a non-windows PC and spend some OS-particular functions (positioning of text cursor, disabling text alternative, getting mouse location and clicks, files regarding the window), I restricted myself to that. Most up-to-the-minute Visual Studio (16.8.0 Preview 4.0) and C++20. It became once odd to like neither ImGui for swiftly adjustments nor the console for debug outputs. Nonetheless the knowing that became once straightforward ample that nearly all issues labored neatly with out.

I abnormal a pair of my all-time popular C++ libraries. For Image IO, stb_image.h never failed me.

For unit testing, I’m a cheerleader for doctest. It does the abnormal issues all unit testing libs function. Nonetheless its killer feature is that the tests don’t dwell in one other mission you never contact however pretty factual subsequent to your code. And so that they traipse whenever you initiate the program (or at any time whereas you repeat it to – I let mine traipse in the debug builds). That design they’re now now not honest tests however are in actuality section of the documentation. No longer exactly obvious what get_triangle() did? Having a explore at these tests factual under couldn’t salvage issues clearer.

constexpr auto moo::get_triangle(const double x) -> double {
   if (much less(x, 0.5))
      return 2.0 x;
      return 2.0 - 2.0 x;
TEST_CASE("get_triangle()") {
   CHECK_EQ(moo::get_triangle(0.0), doctest::Approx(0.0));
   CHECK_EQ(moo::get_triangle(0.5), doctest::Approx(1.0));
   CHECK_EQ(moo::get_triangle(1.0), doctest::Approx(0.0));

It’s underrated and suffers from an uncomfortable title. doctest is first and predominant a unit testing voice for Python. There the title made extra sense as it actually parses purpose docstrings.

Tracy is honest neatly-behaved. Its usefulness, polish and pattern trip blows commercial possible decisions out of the water. There’s extra on Tracy and on the moreover abnormal EnTT below.

I moreover abnormal toml++. I adore the extra gentle-weight in actuality feel of TOML when compared with json. Library spend became once easy, I adore gargantuan readme/documentation. I moreover part the authors views on error handling :).

For infrequent string formatting, I abnormal fmt.

I built-on your total libraries the usage of Vcpkg. And no, I did now now not spend Cmake.

C++ sorts

As the program grew, an rising sequence of variables with varied meanings, however technically equal sorts were born. For better or worse, it’s very straightforward to mix and match them. What’s helpful first rapid descends into exhausting to secure bugs. At that level one among C++ neatly-behaved shortcomings come to gentle: The shortage of straightforward noteworthy sorts.

Obvious you are going to have the option to put in writing noteworthy and expressive sorts, however you discontinuance up having to put in writing a quantity of boilerplate ought to you are going to adore to spend abnormal operators on them. C++20 improved that pretty by providing default comparison operators. Nonetheless ought to you are going to adore to spend arithmetic with your form that wraps Seconds, a quantity of code is wished. There like been abnormal proposals for this however they didn’t creep anywhere as a ways as I’m conscious.

Error handling

With a program as straightforward and deterministic as this, I adore the manner of blurting out an error message, and std::discontinuance()ing the program. Received’t be a advice for all individuals despite the proven fact that.

Performance section 2: Strings

Color adjustments occurs by printing a varied roughly string sequence.

"x1b[38;2;;;m" // foreground color
"x1b[48;2;;;m" // background color

What terminal moo does is for every character on the display conceal to take hang of on a block voice to spend, and inserting these color strings at any time when the colors don’t match the outdated block.

Moreover the worth to render these color adjustments discusses above, these strings in actuality must be constructed first. My first creep-to became once the out of the ordinary fmt library:

fmt::structure(L"x1b[48;2;{};{};{}m", rgb.r, rgb.g, rgb.b);

Rendering a string with 1000 color adjustments takes ~3.2ms. Establishing and appending them with this vogue takes 154.0µs, so about 5% of that time. fmt does like the likelihood of compiling expressions beforehand for sooner parsing, then again it sounds as if that doesn’t work for the desired wstrings. It became once in actuality sooner to diagram the string myself and now now not spend fmt:

std:: wstring str;
str += L"x1b[48;2;";
str += std:: to_wstring(rgb.r);
str += L";";
str += std:: to_wstring(rgb.g);
str += L";";
str += std:: to_wstring(rgb.b);
str += L"m";
return str;

I became once pretty shocked about that.

That ran in 127.3µs (40% sooner). Even sooner is skipping the passing around of the constructed string and appending them into a std::wstring& parameter straight. That takes it all of the manner down to 59.4µs (one other 53% sooner). At that level the string generation takes honest 1.9% of the time to render the ensuing string.

Even sooner is generating all wished colors at program initiate and the usage of color indices. Within the identical scenario that handiest takes 10.3µs (one other 83% sooner). Nonetheless relative to the time of the rendering, the financial savings are small and likewise you lose a quantity of flexibility because you’ve got gotten got to take hang of on all colors on the initiate. That makes issues adore emulated transparency grand more challenging. Also you’ve got gotten got write some wrapping code for the indices to salvage them helpful to spend.

This became once the put I made my first astronomical mistake: I did in actuality spend color indices first. I became once panicked too grand about performance and didn’t diagram for the developed ingredients this made most now now not seemingly. I stopped up altering this later, which took time.

Performance section 3: Tracy

If it’s essential explore into performance of C++ packages, I can’t counsel Tracy ample. Actually seeing graphical representation of when the varied ingredients of your program traipse is priceless and regularly extra insightful than taking a explore at sampling counts. Here is ~9 frames of terminal moo in Tracy:

It’s straight away evident that some frames take hang of design longer than others. Particularly refresh_window_rect() is in total swiftly however continuously gargantuan late. A swiftly explore at Tracys zone histogram confirms this (logarithmic x-scale!):

About every 16 ms or so it’s in actuality late. That’s a time every right-time dev is conscious of: 60 instances per 2d. I narrate Windows in actuality handiest runs that purpose effectively in sync with the video display refresh rate or one thing. It takes up ~23% of the runtime. It could most likely per chance per chance also presumably reasonably be tamed by cutting again the frequency this is refreshed. Here is ‘handiest’ abnormal to effectively stumble on the mouse location relative to the game display conceal, so a pair of instances per 2d would be cheap ample.

I moreover observed a suspicious gap between two Zones of straight adjoining purpose calls. Parameter passing occurs sooner than a purpose body is entered. I by probability handed a string by reproduction and now now not by reference. It took location to be the string that comes with all color codes and characters. That continuously weighs in about 10 KB. No longer a catastrophe performance-wise, however fine to take hang of. No static evaluation instrument warned me about this. This also can presumably be caught in a sampling profiler as a suspicious quantity of time utilize in some string constructors. Nonetheless seeing a straight away gap between two zones salvage this grand more straightforward.

Tracy moreover alerted me to a purpose that became once grand slower than it had any factual to be since it became once honest doing some math. Further inspection yielded that it became once the usage of std::round(), which became once pointless at that level. Taking away that intended I could per chance per chance per chance also rewrite the purpose as constexpr and diminished the runtime of the purpose by 82%.

On the time of writing, – 55% of the time is utilize rendering the string – 23% asking the Windows API regarding the latest window rect – 5% is telling Windows API to purpose the cursor to the top left location – Then comes the right work: 2.0% is background graphics – 1.8% is combining the foreground and background buffers to take hang of on a block voice, FG and BG colors, generate these colors and append every little thing to the rendering string

Any additional optimizations would be easiest utilize in minimizing API calls and cutting again the sequence of colors.

C++ constexpr weirdness

C++ constexpr functions like viewed a quantity of enjoyment in neutral nowadays and are doubtlessly gargantuan highly fine. On the choice hand there is one thing in the abnormal I tripped over twice all the design via this. So the elemental voice about constexpr functions is that they will be abnormal at runtime or at compile time. I made the naive assumption that ought to you uncover a purpose constexpr incorrectly by the usage of a non-constexpr purpose name interior them, that the compiler would throw an error at me since it goes to never be compile-time evaluated. That works in some instances, however technically the abnormal says that whereas it is technically an error, no diagnostic required – that means the compiler doesn’t must give an error.

That’s pretty loopy or at least very varied from all varied ingredients of the language I do know. This capacity that if issues salvage non-trivial, for instance by merely the usage of templates or instances, the compiler will compile a constexpr purpose despite the proven fact that it goes to never be abnormal at compile time. Making an try to pressure a compile-time overview yields a compile error obviously.

Perchance I’ll uncover why the abnormal became once written adore that. Nonetheless for the 2d, there is a fine design of dealing with it: clang-neatly-behaved reports uses adore that as right errors. And even has a warning for constexpr functions that never salvage abnormal in a compile-time context.


I abnormal std::midpoint for the principle time. Riddle: Yell we like got a straightforward color class:

struct RGB {
   unsigned char r, g, b;

If you utilize std::midpoint() to compute the combine of two colors, i.e. spend it on their r/g/b voice-wise. What would you imagine is the shatter consequence of mixing {255, 0, 0}(crimson) and {0, 255, 0}(inexperienced)? It’s {128, 127, 0}! Existence never will get stupid in C++.

I abnormal modules pretty, however in actuality honest to take hang of a explore at them. The labored.. now now not grand to narrate yet.

The default comparison operators (or spaceship operator as the cold kids narrate) work neatly. Thank you committee and compiler devs.


When issues bought extra advanced with the introduction of ufo habits, collision detection and varied roughly projectiles, I offered EnTT. I had upright abilities with it in the previous and it became once a upright match. Utilizing ECS does in actuality feel adore cheating. I mediate there’s in actuality two ingredients to this: The upright section is that the root of decomposing “issues” (lessons/entities) into their ingredients is a highly fine theory that feels factual and works comely in observe. The assorted section I’m extra panicked about is that you just in actuality discontinuance up having a god object that manages all your issues. It feels much less adore C++ because you lose the tight defend a watch on over inputs and outputs of your functions.

One other downside is that it makes debugging extra refined. Since there’ll now not be any longer objects or your depended on STL containers, you are going to have the option to’t with out issues ogle them. And you is also in a position to’t spend your popular functions. Nonetheless all that could per chance per chance per chance also crimson meat up with growing familiarity.

For games, this is a astronomical time-saver. The library itself is rock-stable, the dev is a saint and I diagram on the usage of it extra in varied projects. I in actuality like a tiny sense that ECSs are below-appreciated. Perchance the a puny mysterious charisma they lift doesn’t abet.

Global variables

I technically abnormal global variables for these items (fight me I narrate?):

In a mission adore this, the sequence of rows and columns is valuable for a most fundamental functions. Passing them via as parameters in nearly every purpose didn’t in actuality feel considerably better than honest declaring them as accessible variables someplace obedient, so as that’s what I stopped up doing.

Also I abnormal one globally accessible random quantity generator since that became once required in many different places. The uses modified a lot all the design via pattern and altering purpose parameters your total time became once diagram a pair of worse alternative.

Perfect voice is the config. Wished in many random places, so there’s a global salvage admission to purpose that returns a static object.


Here goes to be blunt and doubtlessly controversial. Please don’t learn this ought to you’re a Git fan.

I don’t adore Git at all. In SVN you’ve got gotten got fine revision numbers to consult. In Git you don’t. Are attempting to commerce a commit message in SVN? factual click on the commit in TSVN and take hang of the instruct. In Git? You ought to search the advice of one of the many sites dedicated to fixing Git. And god forbid it’s now now not the latest commit. And the worst voice is the insane sequence of files in the .git folder. After honest one commit it’s in the thousands. By now terminal moos .git is over 26Okay files, hundreds of folders and 153 MB in dimension. It’s a small mission with ~130KB of code in ~130 commits. That is orders of magnitude previous aim. In upright Git tradition there is an total fluctuate of instructions to repair this. Nonetheless as a cruel joke these fixes are mostly long gone after the following commit, adding insult to harm.

Also continuously there’s these artifacts randomly occurring on your log glance. Nonetheless handiest on some variations of the save in Git binary:

In a single other mission I tried submodules once. They’re irascible. Also continuously Git randomly crashes whereas committing, it did so two instances honest all the design via this mission. Enjoy right in actuality crashes with a windows error message. There’s moreover these fun puny commit errors (this is on top of the crashes, now now not the identical voice):

That that you just can per chance per chance click on ‘abort’ in the varied window. The commit has quiet been made (???) – or has it? No one is conscious of, it’s Git after all. This occurs on about every third commit.

One other of my all-time favorites are the randomly occurring local adjustments of modified line endings.

Clearly there are a lot of strategies of fixing this, however they handiest work continuously. Sure I do know regarding the autocrlf setting. Sure I do know regarding the .gitattributes voice. It labored for roughly two weeks on this mission, then randomly stopped actually in a single day.

I’m obvious Git is a technical surprise ought to you dig into issues. I’m obvious I’m doing issues fallacious. And section of the blame is tooling – I’m obvious there is the next Git GUI that wraps all that for fools adore me. Nonetheless for mere mortals it’s exhausting to explore any wait on moreover its location as de facto abnormal thanks to Github. I would even narrate that for easy packages, now now not the usage of any VCS at all is also better than the usage of Git.

I’ve abnormal Git for over 9 years now. I in actuality like thousands of commits in dozens of repos, then again it never labored neatly for me – and even at all realiably for any cheap time. I’ve had Git files loss two instances, each instances my ass bought saved by the repo being in my Dropbox – which I’ve been made fun of again and again. Even my most fundamental requires like been shattered so again and again that I would never dare to spend any functionality moreover the trivial. I’m too jumpy to spend branches. I don’t even must understand what a rebase is. I would never belief Git’s revert feature to now now not honest slay the repo. Unswerving let that sink in. It’s adore a Monty Python sketch of a VCS and no one is allowed to chortle since the Git zealots wait in every corner prepared to ridicule and crucify. Humanity made a grave mistake by permitting Git to take hang of.

Static evaluation

Visual Studios best gleaming warning diploma is /W4. With /Wall you salvage never-ending errors from third birthday celebration libraries, the abnormal library itself and warnings which could per chance per chance presumably be trivial ought to you don’t function infosec. Nonetheless why does the pretty high /W4 now now not warn me about passing a bool into an int parameter and the varied design round? That warning in actuality existed in earlier variations however became once it sounds as if eliminated.

That’s an effortless mistake to salvage ought to you commerce your purpose signatures around. And it’s constantly unintended.

int int_function(int a) {
   return 1;

int bool_function(bool a) {
   return 1;

bool b = upright;
int i = 5;
int_function(b);  // no warning!
bool_function(i); // no warning!

Clang-Trim moreover doesn’t take hang of these. It did nonetheless secure some varied mistakes: – I technically had a purpose defined too boring in a header file, however Visual studio compiled it at least. – A Mark kept to 'second_size' all the design via its initialization is now now not learn error lead me to a variable I mistakenly didn’t spend. In this case it became once now now not excessive however quiet fine to secure. – Some outmoded listless code that I could per chance per chance per chance also salvage rid of moreover thanks to unused worth warnings. – A bunch of warnings about signed/unsigned comparisons. I mounted these I imagine to be cheap and overlooked the leisure. – The constexpr issues above

Since Clang-Trim is built-in into Visual Studio I secure it pretty easy to spend. It honest continuously “fails” its traipse however quiet outputs your total warnings. Factual ample to let it traipse infrequently. There’s moreover Clang Vitality Instruments which are free for personal spend. That ran sooner and extra legit than the builtin VS clang.

Cppcheck didn’t adore the C++20 spaceship operator and failed exclusively.


I’ve had gargantuan abilities with vcperf since they added the timetrace export. Utilizing it for compile time optimization on a mission adore this is overkill since an total rebuild is below 10 seconds, and most incremental builds are below 1s.

I quiet had a explore and it confirmed the outdated wisdom: , and windows.h are costly, as are most external libraries. The compile instances could per chance per chance per chance also presumably be diminished to a portion by the usage of precompiled headers, or the module variations of the abnormal library. In a single other mission I abnormal it to half the compile time, and that became once grand bigger (in the multi-minute location).

So I can counsel this in abnormal. Own a explore at compile instances of abnormal headers and creep ham.


Somewhat heaps of the code is in step with iterating over the rows and columns and doing some math with that. I stopped up abstracting that into iterators pretty boring, which became once a mistake. Also the abstractions I chose were at least in one case indolent and now now not neatly diagram-out. Nonetheless at that level I kinda ran out of steam to push this to technical perfection since it wasn’t a astronomical deal to repair by varied capacity.

One other mistake became once interesting from my comprise sorts to EnTT pretty too boring. There’s quiet at least two lessons that don’t must exist and will be dissolved in the shut to future.

Outlook and different insights

In observe I secure the foundations for the put C++ purpose definitions must be written cumbersome. “In total” it’s the fundamental header/supply atomize up. Nonetheless then you positively use templates and likewise you’ve got gotten to make clear them in the header file. Nonetheless you in actuality don’t ought to you uncover them effectively in the .cpp. Nonetheless then you positively uncover a purpose constexpr and then you positively in actuality must save them in the header file. I realize the technical causes, then again it’s quiet tense ought to you salvage your preliminary guess regarding the form of the purpose fallacious. This also can in theory be mitigated by IDEs that salvage interesting code straightforward, however in observe even with Visual Assist this is a sport of luck.

Talking about IDEs, there is Visual Assist as an crimson meat up for Visual Studios C++ abilities. I secure it hit or miss. Its rename is fitter than vanilla VS, then again it quiet misses trailing return sorts. Same for its F12 replace: Greater however now now not supreme. I in actuality delight in the alt+m purpose checklist and a-s-f secure reference feature. And the automated consist of will be priceless. Nonetheless VA did salvage worse neutral nowadays and VS is in actuality catching up. Factual work on that by the manner.

Total I like to narrate I secure the IDE abilities bettering, however quiet lacking. Ten years in the past or so in my outdated lifestyles as a Python dev with PyCharm it became once straightforward to extract an expression into a variable and the varied design round. Why is this now now not a component in C++? Of us are talking about AI and the design it’s going to interchange so many roles. Here is ready as life like as 80s SciFi painting a image of flying automobiles being across the corner when after decades my IDE can’t reliably rename a purpose.

Despite its a mountainous sequence of intricacies, I in actuality adore up-to-the-minute C++ overall. I don’t part the glance that integrating libraries into your mission is the language neatly-behaved jam. Even when now now not the usage of Vcpkg, doing issues manually is in total easy. On the least as lengthy as you’re now now not the usage of CMake or varied meta-buildsystems – however that’s in actuality one other arena. The language has many quirks that can’t be mounted for technical causes folks adore me don’t care about at all. I’d adore to narrate that could per chance per chance presumably contain version of C++ that breaks issues left and factual if it capacity having much less madness – however I don’t know ample regarding the small print of the technique to like a great knowing on that.

There are some issues that will be pushed additional in terminal moo. First of your total gameplay factors are barely developed previous a prototype stage. In technical factors I ought to quiet add shadows for cows. And a lot of ufos ought to quiet be fun and comparatively straightforward thanks to EnTT. I’ll presumably take hang of a atomize and then revisit issues.

Read More

Leave A Reply

Your email address will not be published.