Theo’s Creations


More like a playable game-engine demo than a game. The post-processing effects make this beautiful and magical. The style is just wonderful.

Super-fast internally, due to fast hit-detection. (Still the slowest part of the game). Has flyable modiyable floating voxel islands. Could allow users to build their own ships if I had time. Loads of effort spent making small details look / feel nice, like "landing bounce-shock"!

The characters are drawn using SDFs, and spheres using analytical geometry (perfectly smooth surfaces).

The video does not do this game justice! It plays perfectly buttery smooth, smoother than me playing TF2 on my modern PC. I need a new Mac to record and play without stutter! This video is a crime towards the game's smoooothness!


Jeebox can describe computer code, and real-world meaning. The deep idea here, is to describe code meaningfully. So we want to describe code, like how humans think about code. This way, we can form the basis of an artificial-intelligence (Jeebox is not AI itself, thats further work).

It's a big concept and there's no short way to describe it, so check out the rest of the website if you want to understand better. Jeebox also has a github page.

Despite the lack of community-interest, I knew this was the only true approach to AI. If adopted Jeebox could do wonderful things, like enabling perfect translation from English to other human-languages! Super-useful for medical/technical fields (orbital satelite manuals) requiring people from different countries.

You could say "There's a lack of community interest", or you could take it as proof "He can see past blind-spots that the community has".

Being extensible makes it useful for simple uses like replacing XML/JSON. So even for simple tasks Jeebox is useful. Compared to XML/JSON, Jeebox is:

• Smaller
• Nicer-looking
• Better string support.

Jeebox is really like a magical thing in it's own. Despite all that crazy awesomeness, the library comes in at only 160KB.


Speedie is a compiler I wrote. Speedie is modern, fast, and easy to use. It is modern because it is Jeebox-based, refcounted and has a clean-design without historical baggage. (like semi-colons).

Speedie is fast. Everything is aimed towards speed, while being easy to use. If a language is hard to use you can't even design fast-code in it! Speedie is also good-looking (enables small, short-code).

For example, strong-typing increases program-speed, while type-inferencing means you almost never need to enter the type within the function-body.

Speedie has tons of small nice features:

• Zero-overhead iterators
• Any type can have functions added to them, from any file
• Exception-less error-handling framework.
• X = Obj[index] is a function call
• X.func() means the same as x.func
• No need to refer to include files by name. Just dump the code into your project's folder! Makes life easy! Only explicitly need to import one project from another.
• Many more


• Functions are found at compile-time, unless explicitly virtual
• Compiles to code that looks like a good C programmer wrote it
• No "Stop the world" garbage collection
• String library is super-fast in general, uses hardware datatypes
• Allocator is 22% faster than ubuntu's malloc
• Zero per-object overhead (beyond the refcount)


• Gives you structs and pointers for when you need to access libraries with C-APIs
• Can call C-functions, and function pointers too.
• Easy to call Speedie from C, cos Speedie functions are C functions.

Speedie code looks like this: (honestly it's my favourite language).

class YourClass (SuperClass) { |string| Name |int| Position |array| SomeStuff |YourClass| Something constructor (|string| Name, |int| Pos) { .position = pos .name = name // speedie doesn't really care about upper-case/lower-case. // except for viewing variable/function names in debugger. // somestuff and something are auto-filled for us. } syntax append (|object| value) { // called whenever someone does obj~value, where obj isa yourclass. .somestuff ~ value } static { function Test { || YC ="fred", 912) // compiler knows YC is a YourClass, by using type-inference yc ~ "hello!" // appends "hello!" into yc.somestuff. yc ~ "goodbye" // appends goodbye printline yc.somestuff[0] // "hello!" } } } // a practical example from my compiler class SCImport { |int| Depth |string| Path |array of File| Files function ImportOne (|Message| ImportLine) { || NameMsg = ImportLine.Last // ImportLine = 'import "SomePath"' (as message) // NameMsg = 'SomePath' (as message) expect (NameMsg is @Str) (NameMsg, 'Must be a string. (eg: import "SomeLib")' ) /* "expect" here, tests that the type of the NameMsg is 'str'. If not, it creates an error on the global error-list, with NameMsg as the error-node and the above helpful error-message. Then the function returns. NameMsg knows everything needed to print the error location for us! All of this in one line of code! */ || name = || P = Compiler.FindProject(Name) // P is a file. expect (P.Exists) ( ImportLine, "Can’t find project at: '${P.Path}' for import: '${Name}'" ) SCImport.Import( name, P, .Depth + 1 ) } }

Speedie compiles itself very fast, and is a fully-featured language despite only having around 550K of Speedie code, mostly because Speedie is very expressive. Here is speedie compiling itself.

theodore$ speedie --self (ĴëêƁoⓧ) loaded successfully. Read Data 0.016 Importing Files 0.034 Transform 0.055 RefCounting 0.023 Parse 0.031 Export Cpp 0.017 Classes created: 42 Total elapsed: 0.177 Input source code: 536KB Calling c++ compiler Test1 Test2 Test3 Installing Speedie: 2019071608

You'll note that it tests itself 3x. This is to make sure that the new version of speedie can compile itself, and that that version can also compile itself! And then finally it recompiles itself using the last version, to make sure there are no changes between test2 and test3. (that compiles are stable). Only then will it allow the new compiler to be installed.

Contact me            Download CV