Dan Wilhelm v3.0 home
contact info
      Dan Wilhelm
        AI - Machine Learning - Software Design
I solve hard problems in software design and artificial intelligence. Academically, I have pursued understanding the human brain through computation.

I've delivered hundreds of professional talks, workshops, and classes. I've performed in over one-hundred improv shows.

I'm always open to discuss research and software collaborations with like-minded people!

Original Generative Art

Quick Glance:
Selected Consultancy Projects:
  • Probabilistic models with microservice implementations, for predicting times and durations of daily activities given imprecise data.
  • Extensive custom data science analysis backend for streaming large data from client software. Comprehensive statistical analysis to determine best metrics.
  • Recommendation system for people matching. Sends large email batches. Records custom marketing analytics allowing exact replay of individual user experiences.
  • Single search box natural-language algorithm utilizing Apache Solr search backend.
  • Highly scalable chatbot using machine learning. Designed and built a custom engine with unique scripting and intent recognition features.
  • Advanced video capture system and video editing software (software/hardware). Extensive kiosk-style multi-program system allows recording, storing, and editing video and metadata on a network. Included machine language routines to control robotic camera arm.
  • For casinos, card game player display and statistics tracker.
  • Real-time photography display and ordering system for professional event photographers.
  • Numerous custom website and app backends that launched to end users. Handled user loads, updating the code with user feedback, and live database migrations.
  • Merged 200+ Wordpress sites using custom-built merge tools. Extensive Wordpress plug-in modifications.
  • Touch-screen photobooth for Startup Chile company Studiosnaps. Automatedly took photos,
  • Caltech. MS, Computation and Neural Systems.
  • Purdue University. BS, Computer Engineering. Minor in Psychology.
    • Took all of Purdue's brain-related courses, including 23 non-major courses in psychology (8 courses, cognitive/perception), biology (9 courses, cell bio/neuroscience), additional mathematics (logic/proofs/statistical methods/probability), and artificial intelligence.
    • Research in Haptics (2 years) and logic-based planning (AI).
    • Cofounded RoboCup robotic soccer team.
Some Fun Projects:

  • Member, ComedySportz LA Rec League (Sep 2011 - Sep 2014).
  • Member, The Wobblies (Flappers Comedy Club) (Jan-Dec 2013).
  • Performed at Mi's Westside Comedy Theatre ("The Draft").
  • Graduated the improv training programs at ComedySportz and Mi's Westside Comedy Theatre.
  • Studied at The Acting Center (Hollywood), The Acting Corp (North Hollywood).

A Fun Business Plan: FunDynamics Business Plan (with Bryan Stroube)
+ First Prize, Krannert School of Management Award for best undergrad business-related report
+ Semifinalist, Undergraduate Division, Burton D. Morgan Entrepreneurial Compeition

Summary: This is my digital senior design project -- a fully-functioning portable eBook reader. My team designed the schematics, routed the PCBs, coded, and assembled everything. The user will insert a USB thumbdrive then navigate its file system on a graphical LCD, selecting the file to view. Then, he or she can use the interface buttons to read the file on-the-go! The unit also features an AC adapter port for automatically recharging the battery.

Why it's cool: This is the culmination of the last four years of my life at Purdue. I've gained a LOT of practical electronics knowledge through this project. Although I'm not going into engineering for my graduate studies, the skills I learn making this will definitely enable me to understand and build compact digital hardware myself in the future, whether for my work or as a hobby. In addition, this idea itself is great -- it is very exciting to work on such a modern product.

Source/Executable (OrCAD/C/Assembly)

Multicycle/Pipelined CPUs

Summary: For ECE437: Computer Architecture, my partner Jeremy Tryba and I wrote two fully functional CPUs in VHDL -- multicycle and pipelined -- then tested them in hardware. These included memory-mapped I/O, full forwarding, early branch handling, a set-associative instruction cache, a direct-mapped data cache, and they fully implemented a MIPS-like ISA.

Why it's cool: In this class, we really got to see the flip side of programming -- instead of writing programs to run on processors, I got to write processors to run programs! These projects also gave me some great insights on how to write programs to take into account processor peculiarities. Many of the concepts are in fact terms you hear all the time when programming (for instance page faults), and now I know better what implications this could have on performance. I'm certain that having this class BEFORE making the GPU below would have drastically affected our design (for the better)! (A note on the sources: I've chosen to not distribute these since the solutions are viable answers for future classes.)

Source/Executable (VHDL)


Summary: For this project, we designed and built a 3D Graphics Processing Unit. The unit supported w-buffering, hardware line rasterization, 3D projections, and matrix operations. It was actually tested on FPGA hardware using a simulated LCD controller/display written in C. We were awarded the ECE 495d AMD Wafer Award for Design Excellence. I should also note that this design is not pipelined (as you can plainly see in the block diagram). The team members were James Doty, Kyle McGhee, Allan Patterson, and myself.

Why it's cool: Everyone on this team was extremely dedicated, and the output was of amazingly high quality. The design document alone was about 70 pages without including source code! The final product worked excellently, rendering a cross pattern for testing 2D pixel plotting and a 3D cube to test everything else. This really gave me amazing insight into how real digital electronics work, and better yet it allowed me to take my low-level graphics experience (see below) to a new level!

Memory Game

Summary: This was the first major hardware project I embarked on, consisting of a Motorola HC12 processor controlling a bank of eight 7-segment LCDs to play a game of Memory. The user inputs his selection on a nearby computer which communicates with the processor through a serial port. This interface could easily have been connected to buttons instead. My team members were Andrew Keller and Kevin McCann.

Why it's cool: This could have very easily been a handheld unit. This was my first experience using a microcontroller not connected to a motherboard, and it was surprising to me how easy it was to use and debug! Experiencing other ISAs from the x86 was fun, but overall they were pretty similar and easy to pick up. This was a fun, straightforward, and fairly quick project.

CNT AFM Simulation

Summary: This demo was written for the 6-DOF Delta Haptic Device for HIRL. Using actual mathematical models derived by Physics and ME professors, we're attempting to simulate using a haptic device the contact dynamics of a multi-walled carbon nanotube "glued" onto the tip of an atomic force microscope. So essentially it's like the user of the Delta is directly controlling the tip, bringing the inconspicous forces that are present in the nanoscale (e.g. capillary forces from hydrogen bonding, orbital interactions, etc.) to the macroscale. This would be useful in sort of visualizing mathematical models to choose good nanotube properties.

Why it's cool: Now we're using a 6-DOF haptic device that even sends torque data to your hand. This project could even lead to full-scale simulation of an atomic force microscope! The graphics are pretty neat, 100% mathematically derived from scatch (i.e. the rotations, Bézier curves, etc.). The nanotube is modelled as a Bézier curve in fact so that it exactly prescribes to the frame pictures mentioned in a paper I read.


Source/Executable (MSVC++ 6.0+)

Haptic Marble Maze Demo

Summary: Written for the PHANToM force feedback device, this demo attempts to simulate as realistically as possible one of those wooden boxes with a maze and a marble inside, except you can't see the insides. The real physical game only lets you know data through tactile and audial clues, and the same goes for this version. My goal was to make it so you could get the marble out 100% without visual cues, and I think I got it pretty close. It feels really good for a haptic demo in my opinion.

Why it's cool: It uses a really fancy 3-DOF haptic device to render lots of mathematically generated forces to your hands, simulating a marble rolling around. It works quite well, and it uses OpenGL to render the box you manipulate and the graphical depiction of the maze. Yes, the texture is stolen from NeHe's tutorial, but that's only because I just wanted a quick texture -- I promise ;-) I kind of just wrote this for fun over the summer to see what I could do with a Phantom haptic device!

Source/Executable (MSVC++ 6.0+, OpenGL)

0 A.D. Prototype Engine

Summary: The first official DirectX prototype engine for the 0 A.D. project. It allows generation of terrain from a heightmap, appropriate lighting, plus it experimented with placing 2D images onto the 3D terrain using some graphics techniques we developed.

Why it's cool: I was the 0 A.D. software lead at the time and wrote this code as a transition from our 2D engine to 3D. It's an actual working Direct3D terrain engine that has experimental realistic 2D images placed on. Plus, it has a really neat loading popup dialog like all of the latest games do. This screenshot was one of the first published by the 0 A.D team in magazines and websites. Unfortunately, I can't give away the source because I donated it to the 0 A.D. team.

Source/Executable (MSVC++ 6.0+, DirectX 8.0+)

Fourier Analysis Tool

Summary: A program I wrote for high school physics that computes the frequency spectrum the long way (Discrete Fourier Transform) from a given sound wave.

Why it's cool: Uses 100% Windows SDK, but it's a big pain to implement some elements like scroll bars. MFC's a better choice for something like this. This is a pretty cool science app too because it's one way for me to tune something like a guitar.

Source/Executable (MSVC++ 6.0+)


Summary: Short for "Parashooting Aliens", this game was the second produced by the CGCT, and it's a hellofa lot of fun. Seriously. Well, just resist the urge to shoot the motherships right off the bat, because then it isn't much fun at all. Hordes of aliens parashoot down to take over your prized pig ... try shooting only the alien, then only their parashoot. Oooh, and try the number keys 1-? for some awesome weapons and sound effects. And for some reason right-click stops the game, so don't click it!

Why it's cool: Again, it uses my XMedia programming library. But more than that, it uses a really cool system I devised for loading in batches of images at once. This game actually has a noticable delay due to loading in assets! Also, I'm using some data structures here -- linked lists to keep track of all of the aliens. Highly recommended game. It also has a menu system and all in the code but not the executable, so it's your task to get that running if you're up for a challenge.

Source/Executable (MSVC++ 6.0+, DirectX 6.0+)

XMedia Programmer's Library

Summary: This is quite possibly the largest library I've written to date. It encapsulates ALL of DirectX 6.0 (minus networking and most 3D stuff) into one easy-to-use library. I'll just let you discover everything else.

Why it's cool: Largest library to date, it works, used in an Intro to C++ class. The image to the left is a CGCT demo I made that demonstrates my panning and animation classes. One of my first big projects with C++, so unfortunately it doesn't use C++ quite as well as it could. XMedia was a terrible choice of name, however, simply because DirectX had a relatively new DirectMedia component, and it would be very easy to get my library confused with theirs.

Source/Executable (MSVC++ 6.0+, DirectX 6.0+)

Civil War Trivia

Summary: Written for AP History, this is a trivia game where two players face off about their Civil War history knowledge. Uses the above XMedia library.

Why it's cool: To its credit, it might actually have about a hundred questions! This is a pretty good example of XMedia's capabilities too. The font is amazingly bitmapped, but I admittedly used another guy's routine for that because the project emphasis was more on getting the questions done.

Source/Executable (MSVC++ 6.0+, DirectX 6.0+)

VESA VBE Presentation System

Summary: I wasn't really interested in developing the OS anymore, so my plans for turning this into the video core of an OS were shot. So instead, I developed it all into a presentation system, similar to MS PowerPoint (minus the WYSIWYG). I developed two entire presentations for it, presenting these at school (one on viruses and the other on psychologist Jung), making the "slides" in Paint Shop Pro. It has neat transitions, animation effects, could run external programs, all in all I was pretty impressed. Oh yeah, and just to dispel my disgust for cancelling my OS project, I prefixed each presentation with a DanOS Loading... screen, when in actuality virtually no loading wait was required.

Why it's cool: I actually did something with the graphics library I wrote.

Source/Executable (DJGPP/NASM)

VESA VBE Banked Mode Library

Summary: A complete programming graphics library that'll do everything you'd ever want, mostly in hand-optimized Intel 386 assembly according to the Video Electronics Standards Association (VESA) Video BIOS Extensions (VBE), which are incidentally still on modern BIOSes (you just can't access them due to WinXP). This implementation was somehow derived straight from the many VESA VBE manuals that VESA produced. Before video cards had enough memory to implement linear framebuffers, they used page buffers where you had to (inconveniently) switch between different video memory pages every 64000 bytes, which could rudely be in the middle of a scan line (note in VGA cards, for example, bit planes even existed which specified one plane per primary color!). We'll just say my library supports this "banked" option because the linear framebuffer implementation is "too easy". Also, interestingly enough, to get around the fact that processors now operated in "protected mode" to get at > 640k of RAM (and thus the BIOS interrupts couldn't be called like in real mode), I had to physically copy the ROM into memory, find the offset of the VESA VBE, then execute that code manually. Interesting way to do it.

Why it's cool: See the summary.

Source/Executable (DJGPP/NASM)

Space Rocks

Summary: We used to joke that this game would run on anything, and indeed it does, even today! (Edit: Confirmed it does not run on 64-bit Windows 8!) Control a ship and make it through field after field of asteroids, visiting planets and upgrading your weapons. Pretty entertaining, if I do say so myself ;-)

Why it's cool: Wow, lots of reasons here. My longest program at the time of its writing, In C and graphics in 100% inline assembly. Manually loaded PCX files, had a global 8-bit palette, had the experience of managing a large production team, PC speaker sound effects, mouse assembly routines, high scores, developed my own custom data packing system to pack all assets into one data file. Note that the digits for the points received that float up are actually copied directly from ROM, and they are distorted on modern computers because they changed the character set stored in ROM so that my 1/2 pixel scaling routine doesn't work as well. Also, egad! Windows changed around their color palette system, so unfortunately the black color isn't the same as it used to be, leaving an ugly white mask around every "transparent" object. (So yeah, you got me. I "cheated" ... but I only did it because the assembly code was much easier if I just directly drew the black colors rather than skipping transparent pixels.)

SIRDS Generator

Summary: This is a really short program, but it has an amazing effect -- it generates SIRDS (Single Image Random Dot Stereograms) from 4-bit color images, using the palette for different depths. Further, I extended the algorithm so that instead of generating random dots, you can input another image to have the background be a set of repeating cars for instance.

Why it's cool: Well, it generates Magic Eye® images! Not only that, it compiles under DJGPP and uses the Allegro graphics library (now THAT brings back memories!). The algorithm was from the text PC Graphics Unleashed, and it is surprisingly simple. Maybe I'll explain it here sometime. In the meantime, just check out the source.

Source/Executable (DJGPP/Allegro)


Summary: A game set in the old world of knights and wizards, it's a dual to the death as two mages wield their magical powers against each other to win fame and fortune.

Why it's cool: Mode 13h 320x200x8 (palletized color), bitmap loading and animation routines, assembly routines linked to the object file for mouse input and Sound Blaster® sound effects, two players.

I started my computer programming hobby in fifth grade, learning Microsoft® QBASIC on my family's first computer, a 486/33 SX (that's 33 MHz!). In elementary school, we used Apple IIes (for which my favorite game was Lode Runner) and Macintoshes. In sixth grade, I started a weekly publication titled CompuNews [Sample Issues] that contained developments in computing as well as QBASIC tips. For those who actually read this far, here are some of my more minor projects (all with source)!

Featuring 100% hand-coded HTML and graphical splendor.