I'm creating an abstraction layer to work with C++, thought you might be interested. Attached are the files required to use it. What it does should be apparent by reading from the top of main () and running the code, you might have to redirect the 4 #includes if you set up your directory structure differently from me. Note stuff.h only contains one function that is required. The program uses an object called obj to achieve the things it does, it does not add this functionality into the bottom level of C++. The key concepts of an obj include: Access members of objects using std::string's Strings can be transferred and stored a lot more easily than types. They can also be combined more easily, a trivial example is ".toString" being made of two parts. Finally they can easily be used as parameters so a function could take some data and member names as parameters. Individual obj members can be added and removed one at a time. One member function can easily be used by several different types. A function can look at aspects of the object it belongs to in order to work out how to behave without any problems or inconsistencies created by the underlying workings of C++. There is no need for all the empty (or otherwise meaningless) member functions that occur near the top of the tree in programs with lots of inheritance, although inheritance possibilities work differently the same sorts of results can be achieved just as easily with less code. CSS like parameters with names and values where any number of them can be used without having to specify the information in advance. Uses boost::any's extensively but you don't have to wrap and unwrap them yourself, less needing to repeat and know definite information about types all the time. Little difference between accessing different types of members such as objects or functions. Want obj's to behave in a fundamentally different way, write members yourself for object without having to edit my files and add them to obj's you create. I'm sure some of this is possible in other ways and put into code as you need it instead of being one big chunk but I think this abstraction layer is useful. I could also use #defines to simplify and enhance the feel of writing code for the user, for example adding some symbols to represent key features instead of having to write a whole word between .'s. It's not as great as it could be at the moment. I think it does everything by copy making it slow and making it so you can't change members when you access them, I wish for it to do everything by pointer to new memory is such a way as it has the Java feal of doing everything the fast way without having to think about it, it could even be smart enough to notice that bools are not efficient this way. I'm not sure how I will fix these things regarding things like how "template <typename T*>" works. Also when you do have to use normal types it might be hard to implement template functions on the obj functions you write. later I will implement removing a member, setting up a type containing various members, more easily creating objects with lots of miscellaneous members (using only one line of code) etc... p.s. I don't have lots of time at the moment to implement due to other commitments, if you like this consider helping with some of it.