I've been (for a month or so) working on my toy programming language called corlang. Its a c-style language with some additions (like member functions, access control, other little things). Corlang compiles to c-code which can be compiled by any standard c compiler.

 Corlang is just a project to allow me to modify on-demand the semantics of the language without having to worry about any release specific functionality (unless of course it becomes usable to others over time :) ).

 Corlang is written in c++ and uses my 'cor64 general purpose library'.

 Eventually, I intend to migrate cor64 (my toy os) to corlang (its currently using a subset of c++).

 Corlang allows in-line c-code with a few parser-specific codes to allow c integration to a corlang program.

  Don't know how far I will go with this project, but it keeps me occupied, so thats something I guess.

A small snippet of .clc code (this code doesn't show all the functionality I've implemented, but it shows some object-oriented parts of it).

object some_obj
public uint64_tp some_member;

public uint32_tp some_func(uint64_tp arg_)
// not exactly like c, you can specify different types for the initialization
// part of the for loop.
for (uint64_tp c1 = 1, uint32_tp c2 = 17; c1 < (c2 + 7); ++c1)
// inner loop.
for_final // this is optional.
// c1 and c2 are still in scope here. You can do what you will with them.

if (c1 == some_member) return 5;

return (arg_ - some_member) + 17;

uint64_tp entry()
some_obj so;
return so.some_func(11);

 Corlang injects constructors / destructors where needed into c function calls in the output c-code.

  Corlang implements the in-function keywords 'return', 'break', 'continue', 'loop until'( I may depreciate this).

Most operators are parsable, as are complex statements (like obj1.obj2().member_1 = (17 * 3);)

 Its getting somewhere and it keeps the brain active.