Anton V. Staaf


Google : ChromeOS (2014 - Jul 2016)

Returned to ChromeOS to help maintain the EC (Embedded Controller) codebase for Chromebooks.

Google : Loon (2011 - 2014)

As one of the original five person team I developed Loons first integrated avionics electronics, solar battery charging, flight termination system, active temperature control and mission critical firmware. As the team grew I hired and mentored many of our additions and took on a shared tech lead role in the avionics team. I have continued to be an individual contributor, but have taken on leadership roles as needed. Some additional contributions:

  • Public speaking to students and press during the New Zealand launch
  • Hardware, software and system design reviews
  • Computer vision algorithms for tracking optical beacons
  • Heading control loop
  • Build and test infrastructure
  • Launched balloons into the stratosphere

Google : ChromeOS (Sep 2009 - 2011)

I was the tech lead for ARM and U-Boot for ChromeOS. This meant directly contributing to the ARM development effort as well as tracking the overall state of the project and making sure that it was moving in the right direction.

  • Developed and maintained build infrastructure to support multiple architectures (x86 and ARM)
  • Wrote hardware bringup and image flashing tools during bringup of multiple prototypes
  • Wrote and cleaned up device drivers for Tegra platform
  • Coordinated with multiple ARM partners, helped them open source and up-stream Kernel and U-Boot changes, as well as flashing tools
  • Traveled to coordinate with and negotiate with multiple OEM and ODM partners
  • Up-streamed many of my own patches to U-Boot and the Device Tree Compiler

Google : OpenGL (Sep 2009 - Feb 2010)

I showed that static validation of GLSL shader code would not be sufficient to ensure that a WebGL application couldn’t perform a denial of service attack on the users machine. My research into the problem and solution contributed to the GL_ARB_robustness extension specification.

Hopkins Marine Station (Oct 2007 - Oct 2009)

As the sole engineer in a biomechanics lab I worked closely with scientists to design and build an embedded computer to measure intertidal wave forces for parameterizing models of organismal responses to environmental stressors. This work included:

  • Determination of the requirements of the sensor
  • Evaluation of novel sensor technologies
  • Development of analog and digital hardware
  • Development of system software, including device drivers for SDCards
  • Printed circuit board layout and assembly
  • Harsh environment packaging
  • Desktop data analysis software
  • Micro power budgeting for long battery life
  • CNC Mill programming and machining
  • Hand Lathe machining

Anton’s Toys and Games (Mid 2006 - Sept 2007)

I formed a sole proprietorship to design:

  • A prototype of an educational children’s toy
  • Solid models for injection molded parts
  • Illumination modeling software to evaluate toy designs
  • Printed circuit boards and electronics
  • Embedded control software

NVIDIA (Jan 2003 - Feb 2006)

Performance Architect in the GPU Architecture group. I developed and maintained:

  • Infrastructure libraries that were used in a number of Architecture projects
  • Performance measurement tools
  • Cross platform build tools
  • Regression testing tools
  • Event coverage analysis library and visualization tools

Green Hills Software (Sept 1998 - Aug 2002)

INTEGRITY systems software engineer. INTEGRITY is Green Hills’ Real Time Operating System. While on the INTEGRITY project I developed from concept to shipment:

  • Shared memory device drivers over CompactPCI
  • High Availability Hot Swap system
  • PCI bus enumeration, configuration and access layers
  • Network Server, rlogin and telnet servers
  • Shell and web server, including module system for extensions
  • RPC autogeneration software and accompanying client/server libraries
  • Module dependency analysis and initialization code during bootup
  • Efficient ThreadLocal storage data structures and access functions
  • Memory and Object management libraries
  • Abstract state machine libraries
  • Message passing libraries
  • Kernel Aware Debugging features for the Multi IDE
  • Flash device driver code
  • Synchronization and TLS components of the posix API
  • Redesign of the hardware abstraction layer and device driver interface code
  • Proposal for a more orthogonal kernel API

MetaCreations Corp. (Feb 1998 - Aug 1998)

  • Developed Text animations and image transitions for Kai’s Power Show.
  • Prototyped multiple engines for next generation of Bryce.

Green Hills Software (June 1997 - Feb 1998)

  • Ported RTMON (Real Time Monitor for INTEGRITY) to Mips-X based system.
  • Developed and defined core INTEGRITY functionality.

Augmentech Inc. (Summer 1996)

While developing a wearable computer to track user location I:

  • Assembled RF/ultrasonic time of flight beacons
  • Developed embedded software for RF/ultrasonic beacons
  • Developed embedded software for peripheral to communicate with beacons

M+ind (Summers 1993, 1994, 1995)

  • Automated test equipment for artificial legs
  • Wrote improved renderer for CAD/CAM software

Personal projects

An Android physics simulation application. Uses accelerometer and touch screen user inputs. OpenGL sprite rendering engine.
A plugin architecture for fast evaluation of scripted vector operations. Currently used to evaluate function trees for fractal renderings.
Signal Processing
Implemented standard and packet wavelet decomposition routines as well as FFT to analyze music.
Ray Tracer
Simple 2, 3, and 4 dimensional ray tracers and casters. Spatial subdivision as well as intersection stacks were used to improve performance. Voxel based terrain renderers.
Particle Systems
Many fractal and physical particle system projects, including interactions with pre-rendered scenes, and geometry databases.
Reaction Diffusion
Simulation of reaction diffusion chemical processes. It generates natural looking textures.
Progressive radiosity engine. The actual rendering was done on a second computer that used my polygon renderer for a real time fly through as the radiosity was updated.
A physically simulated driving program. It uses OpenGL, a freely available rigid body simulator, and my scheme interpreter. Multiple cars can be created, each with a camera that trails behind it.
Polygon Renderer
High performance polygon rendering engine. Used for physical system visualization.
Loop subdivision surface rendering engine using C++ templates and OpenGL.
Physical Simulation
Spring-Mass based physical simulation of deformable fractal objects. Used Runge-Kutta ODE solver for stability.
Neural Networks
Developed a Neural networks package that was capable of back propagation as well as competitive learning. It was used to bet in an AI bridge player, and I used it for face and speech recognition.
A 2D constraint based widget layout engine.
32-bit operating system for Desktops. Wrote boot code and multithreaded protected memory scheduler and context switch code. Included device driver code for keyboard and display.
Spectral Miasma
Linux graphics and sound demo written with another programmer and musician.
A 12 degree of freedom four legged walking robot. Programmed with a static gait that uses skid steering to turn.
A segmented caterpillar robot that could crawl in a straight line. Used to develop crawling gaits. Trained the caterpillar robot to walk using Probabilistic Based Incremental Learning (PBIL is similar to Genetic Algorithms), in a physical simulation of the robot and its environment. Appeared on the Discovery channel.
A two wheeled robot that uses closed loop PID control to balance.
Line following robot that competed in an annual robotics competition at Carnegie Mellon University.


Carnegie Mellon University B.S. in Mathematics/Computer Science, 1997

Relevant Coursework: Computer Graphics I (Witkin) and II (Heckbert), Multivariable Calc., Linear Algebra, Algebraic Structures, Numerical Methods, Discrete Math, Operating Systems, Algorithms, Programming languages, Machine learning I and II, Parallel Distributed Processing (McClelland)

Technical Abilities

Languages: C, C++, D, assembler (x86 (MMX, SSE), MIPS, PPC, ARM, PIC, AVR, various 8/16/32-bit), Lisp, Scheme, Python, JavaScript, Dart

APIs: X11, Posix (including pthreads), OpenGL, OpenEXR, libpng, DirectFB, INTEGRITY, Sockets, and Register level access

Software Development Platforms: Linux, Solaris, FreeRTOS, Bare metal

Hardware Development Platforms: PC, CompactPCI, PC104, Various SBCs


Collapsible envelope for descent of balloon with envelope still attached
Integration of antenna structures into balloon envelopes
Valuation of and marketplace for inter-network links between balloon network and terrestrial network
Attitude control for a high-altitude balloon
Methods and systems for turning an envelope into a parachute
Drag plate for controlled descent of balloon
Balloon envelope with integrated receiver
Integration of antenna structures into balloon envelopes
Computing device user presence detection
Computing device with developer mode


Failure by fatigue in the field:
a model of fatigue breakage for the macroalga Mazzaella, with validation