Humm and Strumm Project

Development Update: Weeks of July 29th and August 5th

2012-08-10T21:06:00.001-04:00

We're going to be starting a new regular blog post sequence to keep you updated on our status and changes that are going within the project. During times of rapid activity, this should run every week; other times will be every few weeks. This post will be a long one, with developments from the past two weeks.

Git Repo split: The Git repo split that we've been planning has been finished. We now have two separate repositories -- one for our engine, which is our current development focus, and one for our game, which will come later. This makes it easier on us and on packagers to separate the engine from the game in releases. This also makes it easier for any users of the engine -- they don't have to download, build, and install the entire Humm and Strumm game to develop a game using our engine. We're really excited about our plans, which set us apart from the other FOSS engines. We hope game developers will be, too.
C++11 requirement: This one has been a major decision for us. C++11 is still very new, and compiler implementation of it is lacking in many areas. However, it gives us amazing new functionality that is hard to get otherwise (specifically, standard <regex>, shared_ptr<T>, and most importantly, multithreaded awareness and standard thread classes). This has been causing us some minor headaches with cross-platform support, as libstdc++ doesn't support some features we use, MSVC's support is depressing, at best, and we need to find alternatives in some cases. It also limits our users to using new compilers, which we aren't terribly happy with. We hope the situation will improve speedily. For reference, Scott Meyers has a set of references for C++11 support.
MSVC11 support: Tim has been paying special attention to improving the experience on Microsoft's newest Visual C++ compiler, committing lots of fixes and enhancements (like an SSE fix and better organization of source files and header files in the IDE).
Code Cleanup and Code Robustness: We've eliminated a little deadweight in the build system and replaced it with a nicer interface, which should make it easier on developers and users alike. I (Patrick) have a branch in my public repo which, when we finish testing it, will fix support for Clang C++11, make for a more stable parser of ISO 8601 dates, and simplify several aspects of the build system.

Those are the big changes from the past few weeks. Over the next few days, we will be designing our window system code from the ground up, to make it more stable. There have been reports of it not working on some systems, so we will aim to make it simple and modular.

If you have any suggestions, questions, or want to help out, join us on IRC (we're #hummstrumm on FreeNode) or send an email to our hummstrumm-user mailing list.

New Contributor

2012-08-04T00:56:00.000-04:00

I've just joined the project to help out with development. My name is Tim Walters or 'realmz' online. Some of areas I've experience with include Linux development, Windows development and OpenGL.

Next Steps

2012-06-22T19:16:00.000-04:00

Now that the 0.6 release is finished, we are now able to concentrate on planning what will go into our next few releases. We have some big changes coming up, and some fun changes, too.

Our first orders of business are two house-cleaning matters:

Multiple Repositories: From the start, we have designed the Humm and Strumm Game Engine to be general-purpose, not tied specifically to the Humm and Strumm game. It should be possible to use our engine in any sort of 3D game, such as a First Person Shooter or some sort of Role Playing Game (although we don't claim our design is optimal for all genres).

On our current infrastructure, however, downloading and using the engine as a library in your own game requires that you also download the Humm and Strumm game (which, granted, is not existent at the moment). To build the engine, you have to also build the game. This is problematic for anyone wishing to play with the engine itself.

This also presents a hurdle to those who package our engine for various GNU/Linux distributions. A package can be dependent on our engine without being dependent on the executable game. It has actually been requested from one of our packagers that we decouple the engine from the game in our infrastructure, to ease packaging.

We are soon going to solve this by separating the game and the engine into separate Git repositories on Google Code. Any working copies that are checked out will be affected. It is recommended that you simply clone the new repositories again after we finish this. We will send an email to our hummstrumm-contrib mailing list before we start this process, and then another one when we finish. One of the developers will also tell anyone on IRC when we start and finish as well.
C++11: For a bit now, we've been investigating the possible use of C++11 in our codebase. Though we already use the C++03 standard (as well as the 1st Technical Report, which most compilers bundle), the new C++11 standard offers many features that really benefit us as a project, ranging from integrated regular expressions support to better Unicode support to a multithreaded programming model. Switching to C++11 would allow us to focus more on the "game engine" parts of our engine, ignoring some of the more trivial tasks we would have had to do.

We've been waiting for C++11 to gain wider support from compiler vendors, however. GCC's and Clang's support levels are rapidly growing (GCC and Clang supported features), and Microsoft's Visual Studio compiler, while lagging behind in core language support, will be shipping a complete C++11 standard library implementation with VC11. Other compilers seem to be implementing it, as well. We think it's time to start using C++11 in our engine, to the degree that current implementations allow.

From now on, you will need a modern compiler to compile and run the Humm and Strumm game and engine. Modern includes recent versions of Clang and of GCC, and possibly MSVC. Our build system will check and alert you if your compiler does not support a feature of C++11 that we use. Please be mindful of this change.

After, that, we will get into some really fun stuff. The Humm and Strumm Engine is finally at the point where we feel that we are ready to add the part of the engine that will make us unique among Free/Open Source Software game engines: full and (hopefully) optimal parallelization. Our ideas are not new in this regard—proprietary engines have already successfully used similar designs, with very good results. To our knowledge, though, our techniques have not been implemented in any FOSS engine so far. This is a little disheartening, but we hope to change that.

We will soon publish a design document with our design. We want to have a working subsystem in either this coming release or in the release after it. Stay tuned for a look at our plans for parallelization.

Other areas we hope to get some work done on is our renderer, our system abstraction code (in the system:: namespace), and the event system (which depends on our multithreading code). We would love to have some helping hands with this, so if you are interested, please contact us on IRC or through our hummstrumm-user mailing list.

Seeking Engine Developers

2012-06-20T02:35:00.001-04:00

Now's an exciting time at the Humm and Strumm Project. With the Version 0.6 release, we have cleared out the last of our "book-keeping" and "tidying" releases, with bits of code that aren't particularly interesting from a game engine perspective, but are necessary to have a working game engine. Development work has started picking up again, and we actually have packages in two GNU/Linux distributions (ArchLinux and The Chakra Project). We're reasonably confident with the stability of our engine, and we're ready to move into new, uncharted territory—to explore strange, new designs; to seek out new contributors and new communities, and to boldly go where no FOSS video game engine has gone before.

Currently, our core team is made up of only two people, and although we have several testers and packages associated with us (whom we wish to thank!), the development on the engine is from the core team, currently. We would like to expand our development team, hopefully allowing us to increase and hasten the work we do on the project, bringing our goal closer to fruition. And we're asking you.

What makes you guys different than OGRE, CrystalSpace, etc? These are wonderful projects, but their goals differ from ours. While you can read our goals in our Engine Requirements Document (direct link, PDF, A4 paper, 157 kB), we'll describe our main difference here. All current (major) FOSS engines lack parallelization support that is both efficient and scalable. It is very tricky to properly implement properly, but it has been done. Modern proprietary engines are able to easily scale to computers from one core to n cores. No FOSS engine can do this. We aim to fix this.

How can we know you are not vapourware? We have been around for three years, and our codebase shows great activity. We also have package managers and testers outside the Project that have contributed time and effort to helping us. We're dedicated to this.

What do I need to know to be on the core team? We need developers who are "fluent" in C++. That is our only requirement. These developers need to be willing to learn about the other technologies that we use (Git version control, a CMake build system, C++11 features, X11 and WinAPI windowing system code, and OpenGL, currently). Any knowledge of these technologies is a plus. Even better would be a developer with experience in real-time threading support or with rendering experience, but these are not required.

How can I be on the core team? You can either ask on our IRC channel (#hummstrumm on Freenode) or, none of the core developers are on IRC, send an email to our hummstrumm-user mailing list.

We would love to have you join us! Stay tuned for an entry describing our goals for the 0.7 release.

RELEASE: Version 0.6

2012-06-17T00:37:00.001-04:00

The Humm and Strumm Game Engine, version 0.6 has been released. This release introduces better integration with the C++ standard library, a new log system, ISO 8601 serialization support, and several stability fixes.

Like all 0.x releases, this release is a pure game engine release—this means no playable game yet. However, these releases are necessary, as they provide the backbone to the rest of the game.

The game engine is available in the gzip and zip formats from the Downloads page.

Stay tuned for our plans for 0.7, which will be big!

Did you know we have an IRC channel?

2012-06-15T17:29:00.000-04:00

We do! We're hosted on Freenode, channel #hummstrumm. It's a great place to ask questions about development, if our developers are online. Regardless, we or other online users can help you get set up building, testing, and using the engine. You can also contact us via our mailing lists or our social network presences.

Stay tuned for our release on Sunday!

PRE-RELEASE: Version 0.6

2012-06-15T01:48:00.000-04:00

The 0.6 version of the Humm and Strumm game engine will be released this Sunday, June 17th.

As with all version 0.x releases, this is only a game engine release. There will be no playable game until version 1.0. This release is the first of our monthly releases, so there is less in it than in previous releases:

ISO 8601 Serialization: Our Date/Time classes can now be serialized to and from a subset of the ISO 8601 standard.
Better integration with the standard library: We've started to integrate ourselves with the standard library much better. This process will continue with the next release.
Logging: An example of the above: we've made our logging system based on the standard iostream library, allowing any class that can be written to std::cout to be able to be written to our log. The log supports multiple configurable backends. (This is the last logging functionality change, don't worry!)
Code Cleanup: We've purged or deprecated some code that is unnecessary now.

0.6 has been a small release, mostly with clean-up and integration work. We are planning exciting and visible changes for 0.7; subscribe to get these updates!

For more information, see the Downloads Page

RELEASE: Version 0.5

2012-03-25T23:29:00.003-04:00

The Humm and Strumm Game Engine, version 0.5 has been released. This release introduces Date/Time utilities, wider platform support, and a trimmer engine.

Like all 0.x releases, this release is a pure game engine release—this means no playable game yet. However, these releases are necessary, as they provide the backbone to the rest of the game.

The game engine is available in the gzip and zip formats from the Downloads page.

PRE-RELEASE: Version 0.5

2012-03-20T18:22:00.002-04:00

The 0.5 version of the Humm and Strumm game engine will be released this Sunday, September 25th.

Date/Time functionality: In the style of the Pokémon Gold and Silver games, which detect the real world time and change accordingly, our engine supports a programmatic interface to detect the current date, time, and timezone information.
Flexible logging: The engine's logging capabilities have been made much more flexible, allowing for multiple logs, user configurable logging, and modular logging.
Compiler checks: In addition to GCC, we now detect and explicitly support the new Clang C++ Compiler, about which interest has been rising both in the GNU community and in the *BSD community, due to its speed, modularity, and permissive license. Furthermore, if the compiler supports the new C++11 standard, we make use of some new features (though we still support non-C++11 compilers).
Bug fixes: We are at the point where we feel the engine is stable enough to be packaged and used (though it doesn't provide many tools to game developers yet).

For more information, see the Downloads Page

Engine Requirement Document

2011-12-22T03:47:00.002-05:00

The Humm and Strumm Project has released the first version of its Engine Requirements Document. This document details the requirements analysis for the Humm and Strumm Game Engine in non-implementation-dependent terms, providing an overarching philosophy and requirements set by which the engine will be designed and implemented.

This document is the first version of the Engine Requirements Document, which may change due to unexpected requirements changes or requirements not realized during the initial project requirements analysis. Newer versions of this document will be available via the same link.

The document is available in PDF (A4 paper) format (direct link, 156 kB).

Social Media

2011-11-28T22:48:00.015-05:00

In addition to subscribing to the RSS feed for this blog or subscribing to the various mailing lists that we use, we are also introducing several new means of receiving updates from the Project.

If you are a DIASPORA* or Friendika user, you can add our new DIASPORA* profile as a contact. Simply type in our OAuth handle (hummstrumm@diasp.org) to the subscribe bar, just as you would to add any other contact. We'd like to thank David Morley for hosting this community-run, open pod.

If you are a Status.Net user, GNUSocial user, or a user of any social network that supports the open OStatus standard, you can subscribe to our new Status.Net profile. You'll need to enter our OAuth handle (hummstrumm@parlementum.net) in the remote subscribe box on your social network. We'd like to thank Charles Roth for hosting his Parlementum StatusNet server, on which we created our account.

These will have frequent updates on the status of the project, more frequent than those on this blog. If you are interested in knowing the latest updates, we think these two solutions will benefit you greatly.

RELEASE: Version 0.4

2011-11-28T17:48:00.000-05:00

The Humm and Strumm Game Engine, version 0.4 has been released. This release introduces Windows window system code and several stability fixes.

Like all 0.x releases, this release is a pure game engine release—this means no playable game yet. However, these releases are necessary, as they provide the backbone to the rest of the game.

The game is available in the gzip and zip formats from the Downloads page.

PRE-RELEASE: Version 0.4

2011-09-06T10:45:00.002-04:00

The 0.4 version of the Humm and Strumm game engine will be released this Thursday, September 8th.

Win32 rendering: Having revamped our window system code, we now have support for both X11 and Windows rendering. For the user, this means that our rotating cube demo from the previous release now works on all platforms that the Humm and Strumm engine currently supports: GNU/Linux, *BSD, and Windows.
Stability fixes: We've introduced a few fixes that should better the stability and extensibility of the engine. Most of this work was done behind the API, so there isn't much that the user of the engine might see.

For more information, see the Downloads Page

Moved to Git Repository

2011-08-22T20:12:00.005-04:00

Along with work on the upcoming 0.4 release, this past month has seen an important infrastructure change in the Humm and Strumm Project. Our code is now being stored in a public Git repository (which you can clone using these instructions). This change should result in a more efficient workflow for developers and for contributors.

Some background: our code has been stored in a version control system called Subversion, where there is one central repository to which everyone commits. Having a version control system allows us to revert changes, track additions effectively, and collaborate with contributors and developers across the world. Until now, this has been quite fine in facilitating our development on Humm and Strumm

Enter Git, the distributed version control system. Instead of having only one repository to which everyone commits, everyone has at least one repository for themselves. All their work is done on their personal repository; the changes are then merged into the project's master repository.

The benefits of Git are twofold:

Easy merges: In Subversion, merges can be a nightmare. It was a lot of work to schedule merges of changes that both developers made. This was counterproductive—time that could have been spent developing and testing was instead spent fixing problems caused by merges. With Git, merges are (usually) brainless. We don't have to find time to schedule merges or to fix merge problems. They just work.
Easy contributing: Because of the decentralized nature of Git, anyone can make a clone of our repository. This includes both developers and potential contributors. Due to the increased ease of merging, it's far easier to for anyone to contribute to the project. For a detailed (updated) description of how to contribute, see our contribution policy.

For most users, this shouldn't have any direct effect. However, on the development end, we now have an even more efficient way to work on the game, hopefully resulting in quicker development.

RELEASE: Version 0.3

2011-08-03T00:44:00.003-04:00

Here is the first of our upcoming monthly releases!

This, like all 0.x releases, is a pure game engine release—this means no playable game yet. However, these releases are necessary, as they provide the backbone to the rest of the game.

We have a lot of functionality now: see the NEWS file for all the changes.

The game is available in the gzip and zip formats from the Downloads page.

PRE-RELEASE: Version 0.3 and New Release Cycle

2011-07-21T09:31:00.006-04:00

After a short delay, the Humm and Strumm engine version 0.3 will be released on Monday, July 25th.

As with all version 0.x releases, this is only a game engine release. There will be no playable game until version 1.0. What's new in this release?

X11 rendering: We now have a window that appears on X11 enabled systems displaying a rotating cube. Windows native windowing system support will come with the next release.
Port to *BSD: Humm and Strumm now supports *BSD systems out of the box. This support has been tested with FreeBSD x64. (Be sure you have an up-to-date version of GCC when compiling).
Geometry Mathematics classes: Geometry mathematics classes such as AABBs and ellipsoids have been added. They support collision checking and detection.
SSE: Streaming SIMD Extensions support, which speeds up the processing of vector mathematics (on which game engines are built), is now included in the engine.

CPPUnit for Windows: We have a version of CPPUnit bundled with the game engine now for Windows, because it is extremely hard to compile and download for modern versions of Windows.
System Detection: Various attributes about the system, including clock frequency, memory usage, and processor flags, can now be detected at runtime.
Build System Refactoring: The build system has been refactored internally, which makes maintaining it much easier. For users, this is most apparent in the robustness in case of failure: if a package isn't installed, the build system will alert them.

For more information, see the Downloads Page

Additionally, the Humm and Strumm Project is adopting an aggressive release cycle of once per month releases. These releases will be smaller, but much more frequent. Hopefully, this will allow us to better pace our releases and follow the adage of "Release Early, Release Often". To see upcoming releases, see our release calendar.

Mailing Lists

2011-02-06T22:03:00.001-05:00

Did you know that Humm and Strumm's mailing lists are open for all to subscribe to? They are a great way to communicate with us, to keep up with recent features, and to join the community!

We have four mailing lists that we use for interaction:

hummstrumm-user: For release announcements and general communication with the users. At the moment, this mailing list is very low volume, but we would love to have more discussion on it. If you have a question, a problem, or just want to talk to us, please post here.
hummstrumm-contrib: For interaction with contributors and posting of patches. Anyone who has a patch to contribute, but doesn't want to become a full-fledged member of the team can request to subscribe to this list and post here.
hummstrumm-dev: For interaction between developers. This is a pretty high volume, as it is the main way developers communicate in the project. Anyone can subscribe, but only we can post. Subscribing is a great way to keep up-to-date with development news and discussions.
hummstrumm-updates: For automatic updates concerning bug reports, commits, and wiki edits. This is very high volume, but anyone who wants to keep up with the development of Humm and Strumm should subscribe.

How do I subscribe to these mailing lists? For each one except hummstrumm-contrib, send an email to listname+subscribe@googlegroups.com, where listname is the name of the mailing list as given above. For hummstrumm-contrib, first send an email to hummstrumm-user to request to join. Be sure to tell us what patch you have or plan on developing. We'll certainly add you.

UPDATE 2012-02-14: We've now opened up our hummstrumm-contrib to everyone. You can subscribe in the same way as the others listed.

Consider subscribing; we'd love you to join the community.

New log, new platform, and some old fixes

2010-11-28T23:32:00.000-05:00

Some miscellaneous news on Humm and Strumm:

Experimental *BSD support: We now have BSD specific code in the engine. This code is highly experimental...so experimental that it hasn't even yet been compiled on a BSD system. If you would like to test it out, join our User Group and download our latest source code, from the branch PatrickNiedzielski.
XML-based Log: Our logging class now logs to a pure XML file. You can convert it to HTML or plain text by means of XSL stylesheets. The new log also contains lots of useful information, like filenames, line numbers, function names, and system attributes (soon to have timestamps).
CPPUnit for Windows: Since we are using an old version of CPPUnit (not the latest, experimental version 2), we needed to port it to new versions of Windows. This version is fully integrated with our build system.

Reference Counting Fix: The fundamental means of reference counting in our engine has been flawed; it would fail for elements of arrays on the heap, and members of other Objects on the heap. We've fixed this with something called AllocationTable, which tracks the allocations from the heap until when they are constructed and then setting the initial Object reference count accordingly. This solution is by no means final. We are still investigating other methods.
Custom Allocators: For the sake of both speed and robustness, we are currently looking at various allocators to replace our custom one. They will be more robust, better tested, and more optimized. This will cut down on inexplicable errors we have sometimes gotten, especially in SSE.
Wiki Revamp: Our wiki has been revamped to make it easier to get the information you want. There will be a few more minor modifications in the future, too, to ease the navigation. Our wiki is a good place to get information about our project for both users and developers alike.

Development Continues...

2010-08-31T11:32:00.001-04:00

As the hot summertime in the northern hemisphere draws to a close, we are hard at work on the Humm and Strumm game engine. Yes, sorry about the lack of posting recently. Perhaps we should be doing posts every week as opposed to every few months.

Development News:

Unicode Support: Our Character and String classes have almost been fully implemented with Unicode support. This includes UTF-8, UTF-16, and UTF-32 formats, with rigorous error checking on input characters. Characters outside the BMP (Basic Multilingual Plane) can be stored (in case you, for some reason, need to store a Mahjong tile in a string?). You can find more about our Internationalization requirements on our wiki.

Windows Unit Testing: The Humm and Strumm Engine finally compiles on Windows (or it will, with the next check-in on my branch). We had to port our unit testing system, CPPUnit, to Windows; now, however, we should be able to run unit testing out of the box. There does seem to be one error, though.
X11 Window: We have code for the X11 system, to make a window appear (which is a thrill to have!) This code will be ported to Windows with the next release.
SSE Math: After doing extensive testing, we have found that writing custom SSE code does offer a benefit over that generated by GCC. The same is probably true with MSVC. We are using compiler intrinsics functions to keep things cross-platform if possible, and because Win64 doesn't support inline assembly code(!)
List Class: We have decided not to offer a true array or vector (in the computer science sense of the word) class, in which all elements are contiguous in memory. Instead, we offer a specially optimized linked list, which facilitates random access more quickly than a standard linked list. We call this technique a Service Centre Linked List, which you can read about on our wiki, at the Ideas Sandbox page.

Hopefully, we can get a release in by mid-September. Hopefully. This should also have some nice concept art for you all to see.

Looking ahead to the 0.4 release, we will have the biggest subsystem implemented yet: the Event System, which ties in with the Threading System. The multithreading design for Humm and Strumm is designed to take advantage of all the cores on the system, while keeping some processes in serial, allowing easy updates and message passing between entities in the game world and subsystems in the engine.

Oh, and this is the new and final website design. It finally looks acceptable.

First Design Session

2010-06-01T00:24:00.000-04:00

Our first design decisions conference will be this weekend, via a private chat between me and Ricardo. Future design sessions may be hosted some other way, but for now, with the two of us working on it, this works well.

I hope to discuss the following points:

Multithreading
A messaging system
Scene management

Further points may be addressed as needed.

For those interested, I will be putting a document up online either on our Project Documentation Site or our Wiki space. I hope to make the process as transparent as possible for anyone to see, so all ideas and debate relating to the game will be recorded. Feel free to post your comments on the design session either directly on the website (both the documentation site and the wiki allow this) or send them to our hummstrumm-user group.

RELEASE: Version 0.2

2010-05-15T18:28:00.000-04:00

We've another release under our belts now, and get ready for many more to come.

This, like all 0.x releases, is a pure game engine release—this means no playable game yet. However, these releases are necessary, as they provide the backbone to the rest of the game.

This release adds on to the core functionality by introducing debugging helpers, type wrappers, and some system functions. It also has the basis of the rendering engine--the Vector Algebra mathematics classes. Both of these developments will directly lead us to the higher level engine systems.

Furthermore, we have started to migrate to CppUnit for our test cases. To compile, you will need this.

The game is available in the gzip and zip formats from the Downloads page.

PRE-RELEASE: Version 0.2

2010-05-08T13:36:00.000-04:00

Another release is coming up next weekend, and we are coming to a fuller basis for the game.

As with all version 0.x releases, this is only a game engine release. There will be no playable game until version 1.0. Here's what we've done in this release:

Vector Math: The Math System provides normal linear algebraic operations on vectors, matrices, and quaternions. This work forms the start of the Graphics and Scene Management Systems.
Debugging System: The Debugging System allows for easy compile-time and run-time debugging. We've provided a class for profiling execution of a block of code, a class for logging information to the disk, and magic macros that will help in debugging the engine and the game.
Types: The Types System provides wrapper classes for the standard C++ built-in types. In doing this, we can add additional functionality to the types, and more importantly, we can integrate an ECMAScript-compatible language in with existing C++ code.

We have also added some test programs for each module, using the CppUnit test framework. If you want to help write or improve these test cases, you can send us patches or files via our hummstrumm-contrib Google Group. We accept all contributions.

For more information, see the Downloads Page.

Subversion Repository Layout

2010-03-25T01:18:00.001-04:00

This is a quick update: So until now, we've been polluting our trunk with changes to the codebase. Not a good thing! Ricardo suggested that we instead have separate sandbox branches for each developer in our repository on which to play around. I have just implemented this in our repo. In addition, there is an unstable branch, in which code is committed for a series of tests before going into the stable trunk. I think it will fit in nicely with code reviews, which could be done before we merge our personal branch in with the unstable branch. For any new team members, we will create a new branch based on the Google Code user name of the contributor. This will help organisationally and logistically.

Blog Redesign

2010-03-09T16:28:00.000-05:00

As you have probably noticed, I have been redesigning the development blog. It is definitely much more user-friendly than before. Now, as opposed to the old standard Blogger template, we have a custom designed web site.

My hope is that this can become our main homepage for the Humm and Strumm project, as opposed to the current (ugly) Google Code page. The Blogger blog affords us much more flexibility, and will perhaps create a more positive and professional image of our project to those first finding it. Making this our home on the web will also allow people to easily see development news—it is a blog, after all! All information will be available on the blog site, and links to the Wiki, Downloads Page, and Issue Tracker will give easy access to these services from Google Code.

Team member introduction

2010-03-03T08:27:00.005-05:00

Hi all, I'm Ricardo Tiago, I just joined the team and I will work for now on the graphics subsystem. Its a pleasure to be part of this project!