I'm Ethan, a doctoral candidate at Oregon State University. I'm interested mainly in computer
graphics, but I enjoy working on a variety of projects as well. I graduated from the University
of Washington in Seattle with a BS in Computer Science in 2024.

Lythium is the successor to Lithium. Unlike Lithium, Lythium is a 2D game engine, but features many
improvements in architecture and usability.

Lythium is written in C++ and Lua and uses OpenGL for hardware-accelerated rendering. The engine
comes packaged with a graphical editor and supports scripting in C++ or Lua. It is cross platform,
supporting Windows, Mac and Linux.

Lithium is a 3D game engine written in C++ and uses OpenGL for hardware-accelerated rendering.

Uses a deferred rendering pipeline by default and a Physically Based Rendering lighting model
alongside several modern post-processing effects.

Supports authoring C++ scripts to control game behavior, a complex resource system which manages
resources automatically and only loads what is necessary at a single moment.

lysys (Lythium System) is a C library that provides a cross platform abstraction layer for
OS-specific functionality. Its original purpose was to simplify the process of writing code within the
Lythium engine, but it has since been expanded to be a standalone library.

lysys supports abstractions for the following:

• Synchronous and asynchronous file I/O
• File creation, deletion, and renaming
• Anonymous and named pipes
• Clipboard interaction
• Memory protection management
• Memory mapped files
• Process creation and management
• Cryptographically secure random number generation
• Shell interaction
• File information retrieval (e.g. file size, file type)
• Directory creation, deletion, and listing
• File system snapshotting
• File system monitoring
• Locks and condition variables
• System performance monitoring
• Battery status monitoring
• Thread creation and management
• Thread local storage
• Fiber creation and management
• High resolution timers
• Common directory retrieval (e.g. user home directory, documents)

libscratch3 is a cross-platform C++ library that provides a compiler and runtime for the Scratch 3
programming language, developed by the MIT Media Lab. Scratch is a block-based programming
language aimed at teaching programming concepts to children. The project provides an additional
C API if desired.

libscratch3 reads .sb3 files, the file format used by Scratch 3, and compiles the blocks info
an intermediate bytecode format, readable by the libscratch3 runtime. The runtime executes the
bytecode and displays the output in a window, allowing the user to interact with the Scratch project.

The renderer is hardware accelerated using OpenGL, supporting 2D sprites, text, and vector
graphics. Due to the simple nature of Scratch's visuals, the renderer has very low overhead, with
the performance of a project mainly dependent on the complexity of the Scratch project's logic.

Scripts execute very fast, due to the use of the custom bytecode over interpreting the Scratch
blocks directly and optimizations performed at compile time that cannot be done in the Scratch
editor due to the user's ability to modify the project at any time.

The runtime also features a debugger, allowing live introspection of the project's state, including
variable values, running scripts, resource inspection, performance monitoring, and the ability to
trigger events manually.

This project is still in development, with some described features being in development branches.
Also check out my Scratch profile for some of my Scratch projects. Most of them will likely
not be runnable with libscratch3, as most use features that are not yet implemented.

MatrixUtil is a library written in C++ to handle vector, matrix, and quaternion calculations.
The library uses Intel SIMD Intrinsics for fast computations. Support for ARM Neon is currently
in development.

					#include <mutil/mutil.h>
					
					using namespace mutil;
					
					int‌ main(int argc, char *argv[]) {
					‌   Vector4 p(1.0f, 3.0f, 5.0f, 1.0f);
					‌   Vector4 t;
					
					‌   // create matrix that rotates 45 degrees around x axis
					‌   Matrix4 M(1.0f);
					   M = rotate(M, radians(45.0f), Vector3(1.0f, 0.0f, 0.0f));
					   t = M * p; // applies M on p
					
					
					‌   // same thing, but using quaternions
					‌   Quaternion q = rotateaxis(Vector3(1.0f, 0.0f, 0.0f), 45.0f);
					   t = rotatevector(q, p);
					
					‌   // another way to use quaternions
					   t = torotation(q) * p;
					
					‌   // convert between quaternions and euler angles
					   q = fromeuler(45.0f, 0.0f, 0.0f);
					‌   Vector3 euler = toeuler(q);
					}
					
				

• mtgl - A multithreaded OpenGL abstraction library.
• hexview - A cross-platform, command-line binary file viewer.
• lscript - A statically typed scripting language.
• Java-BSP - A Java implementation of the Binary Space Partitioning algorithm.
• HttpServer - A simple Windows HTTP server written in C++.

GitHub: evrhel
LinkedIn: ethan-vrhel
Resume: Resume (Download)
Contact: evrhel(at)cs.washington.edu