diff --git a/.cproject b/.cproject
index 513d325203bb..5010daca4169 100644
--- a/.cproject
+++ b/.cproject
@@ -21,7 +21,7 @@
 					<folderInfo id="0.223161107." name="/" resourcePath="">
 						<toolChain id="org.eclipse.cdt.build.core.prefbase.toolchain.1490918522" name="No ToolChain" resourceTypeBasedDiscovery="false" superClass="org.eclipse.cdt.build.core.prefbase.toolchain">
 							<targetPlatform binaryParser="org.eclipse.cdt.core.MachO64" id="org.eclipse.cdt.build.core.prefbase.toolchain.1490918522.582651722" name=""/>
-							<builder buildPath="${workspace_loc:/drake}/" command="make" enableAutoBuild="false" id="org.eclipse.cdt.build.core.settings.default.builder.188937989" incrementalBuildTarget="all" keepEnvironmentInBuildfile="false" managedBuildOn="false" name="Gnu Make Builder" superClass="org.eclipse.cdt.build.core.settings.default.builder"/>
+							<builder arguments="VERBOSE=1 -j8" buildPath="${workspace_loc:/drake}/" command="make" enableAutoBuild="false" id="org.eclipse.cdt.build.core.settings.default.builder.188937989" incrementalBuildTarget="all" keepEnvironmentInBuildfile="false" managedBuildOn="false" name="Gnu Make Builder" superClass="org.eclipse.cdt.build.core.settings.default.builder"/>
 							<tool id="org.eclipse.cdt.build.core.settings.holder.libs.1300060025" name="holder for library settings" superClass="org.eclipse.cdt.build.core.settings.holder.libs"/>
 							<tool id="org.eclipse.cdt.build.core.settings.holder.1897653860" name="Assembly" superClass="org.eclipse.cdt.build.core.settings.holder">
 								<option id="org.eclipse.cdt.build.core.settings.holder.incpaths.478355067" name="Include Paths" superClass="org.eclipse.cdt.build.core.settings.holder.incpaths" valueType="includePath">
@@ -91,7 +91,7 @@
 					<folderInfo id="0.223161107.510608512." name="/" resourcePath="">
 						<toolChain id="org.eclipse.cdt.build.core.prefbase.toolchain.822542901" name="No ToolChain" resourceTypeBasedDiscovery="false" superClass="org.eclipse.cdt.build.core.prefbase.toolchain">
 							<targetPlatform binaryParser="org.eclipse.cdt.core.MachO64" id="org.eclipse.cdt.build.core.prefbase.toolchain.822542901.625733607" name=""/>
-							<builder arguments="-j8" buildPath="${workspace_loc:/drake}/" command="make" enableAutoBuild="false" id="org.eclipse.cdt.build.core.settings.default.builder.693997493" incrementalBuildTarget="debug" keepEnvironmentInBuildfile="false" managedBuildOn="false" name="Gnu Make Builder" superClass="org.eclipse.cdt.build.core.settings.default.builder"/>
+							<builder arguments="BUILD_TYPE=Debug VERBOSE=1" buildPath="${workspace_loc:/drake}/" command="make" enableAutoBuild="false" id="org.eclipse.cdt.build.core.settings.default.builder.693997493" incrementalBuildTarget="" keepEnvironmentInBuildfile="false" managedBuildOn="false" name="Gnu Make Builder" superClass="org.eclipse.cdt.build.core.settings.default.builder"/>
 							<tool id="org.eclipse.cdt.build.core.settings.holder.libs.259768903" name="holder for library settings" superClass="org.eclipse.cdt.build.core.settings.holder.libs"/>
 							<tool id="org.eclipse.cdt.build.core.settings.holder.664075779" name="Assembly" superClass="org.eclipse.cdt.build.core.settings.holder">
 								<option id="org.eclipse.cdt.build.core.settings.holder.incpaths.845811980" name="Include Paths" superClass="org.eclipse.cdt.build.core.settings.holder.incpaths" valueType="includePath">
diff --git a/.gitignore b/.gitignore
index bbb53efcc2f3..5b4e2ba37450 100644
--- a/.gitignore
+++ b/.gitignore
@@ -82,3 +82,8 @@ bin
 drake.jar
 *.out
 urdf_kin_test
+pod-build
+lcmtypes/c
+lcmtypes/cpp
+lcmtypes/java
+lcmtypes/python
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 000000000000..d2f2d0f51f91
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 2.6.0)
+
+set(POD_NAME drake)
+include(cmake/pods.cmake)
+include(cmake/lcmtypes.cmake)
+
+lcmtypes_build() 
+
+
+#add_subdirectory(util)
+#add_subdirectory(algorithms)
+add_subdirectory(systems)
+
diff --git a/Makefile b/Makefile
index f3ea00a633bb..7cff07b0e39d 100644
--- a/Makefile
+++ b/Makefile
@@ -1,93 +1,49 @@
-
-# Note: make will automatically delete intermediate files (google "make chains of implicit rules")
-
-CC = gcc
-CXX = g++
-PKG_CONFIG_PATH := ${PKG_CONFIG_PATH}:$(shell pwd)/thirdParty
-
-LCMFILES = $(shell find . -iname "*.lcm" | tr "\n" " " | sed "s|\./||g")
-SUBDIRS:=$(shell grep -v "^\#" tobuild.txt)
-
-LCM_CFILES = $(LCMFILES:%.lcm=%.c) 
-LCM_CFLAGS = $(shell pkg-config --cflags lcm)
-LCM_LDFLAGS = $(shell pkg-config --libs lcm)
-EIGEN_CFLAGS = $(shell pkg-config --cflags eigen3)
-
-#CFILES = $(LCM_CFILES)
-LCM_JAVAFILES = $(LCMFILES:%.lcm=%.java)
-OTHER_JAVAFILES = util/MyLCMTypeDatabase.java util/MessageMonitor.java util/CoordinateFrameData.java util/LCMCoder.java util/Transform.java
-JAVAFILES = $(LCM_JAVAFILES) $(OTHER_JAVAFILES)
-
-OBJFILES = $(LCM_CFILES:%.c=%.o) 
-CLASSFILES = $(JAVAFILES:%.java=%.class) 
-EXTRACLASSFILES = util/MyLCMTypeDatabase*MyClassVisitor.class
-
-MATLAB = $(shell which matlab)
-
-all: matlab_config java c
-	@for subdir in $(SUBDIRS); do \
-		echo "\n-------------------------------------------"; \
-		echo "-- $$subdir"; \
-		echo "-------------------------------------------"; \
-		$(MAKE) -C $$subdir all || exit 2; \
-	done
-
-debug: CXX += -g
-debug: CC += -g
-debug: matlab_config java c
-	@for subdir in $(SUBDIRS); do \
-		echo "\n-------------------------------------------"; \
-		echo "-- $$subdir"; \
-		echo "-------------------------------------------"; \
-		$(MAKE) -C $$subdir debug || exit 2; \
-	done
-
-doxygen :
-	doxygen doc/Doxyfile
-
-java : drake.jar
-
-c : drake.a 
-
-matlab_config : util/drake_config.mat .matlabroot
-
-util/drake_config.mat .matlabroot : configure.m
-	matlab -nosplash -nodesktop -r "configure;exit";
-# todo: consider using configure(struct('autoconfig',true))
-
-drake.jar : $(CLASSFILES)
-	cd ..; jar -cf drake/drake.jar $(CLASSFILES:%=drake/%) $(EXTRACLASSFILES:%=drake/%)
-
-drake.a : $(OBJFILES)
-	ar rc $@ $^
-
-.INTERMEDIATE : $(OBJFILES) $(CLASSFILES)
-.PRECIOUS : $(LCMFILES) $(OTHER_JAVAFILES)
-
-util/LCMCoder.class : util/LCMCoder.java util/CoordinateFrameData.class
-	javac $< -cp $(CLASSPATH):$(shell pwd)/../
-
-%.class : %.java
-	javac $<
-
-%.o : %.c
-	$(CC) -c -I include/ $< -o $@ $(LCM_CFLAGS) $(EIGEN_CFLAGS)
-
-%.c : %.lcm
-	@if grep -i package $< ; then echo "\n *** ERROR: $< has a package specified.  Don't do that. *** \n"; exit 1; fi
-	lcm-gen -c --c-cpath="$(shell echo $< | sed "s|/[A-Za-z0-9_]*\.lcm|/|")" --c-hpath="include/" $< 
-
-%.java : %.lcm
-	@if grep -i package $< ; then echo "\n *** ERROR: $< has a package specified.  Don't do that. *** \n"; exit 1; fi
-	lcm-gen -j --jdefaultpkg="drake.$(shell echo $< | sed "s|/[A-Za-z0-9._]*\.lcm||g" | tr "/" ".")" --jpath=".." $<
-
-clean : 
-	-rm -f drake.jar drake.a $(LIBS) $(LCM_HFILES) $(LCM_CFILES) $(OBJFILES) $(LCM_JAVAFILES) $(CLASSFILES) $(EXTRACLASSFILES)
-	-rm -rf doc/DoxygenMatlab/html 
-	@for subdir in $(SUBDIRS); do \
-		echo "\n-------------------------------------------"; \
-		echo "-- $$subdir"; \
-		echo "-------------------------------------------"; \
-		$(MAKE) -C $$subdir clean; \
-	done
-
+# Default pod makefile distributed with pods version: 12.11.14
+
+default_target: all
+
+# Default to a less-verbose build.  If you want all the gory compiler output,
+# run "make VERBOSE=1"
+$(VERBOSE).SILENT:
+
+# Figure out where to build the software.
+#   Use BUILD_PREFIX if it was passed in.
+#   If not, search up to four parent directories for a 'build' directory.
+#   Otherwise, use ./build.
+ifeq "$(BUILD_PREFIX)" ""
+BUILD_PREFIX:=$(shell for pfx in ./ .. ../.. ../../.. ../../../..; do d=`pwd`/$$pfx/build;\
+               if [ -d $$d ]; then echo $$d; exit 0; fi; done; echo `pwd`/build)
+endif
+# create the build directory if needed, and normalize its path name
+BUILD_PREFIX:=$(shell mkdir -p $(BUILD_PREFIX) && cd $(BUILD_PREFIX) && echo `pwd`)
+
+# Default to a release build.  If you want to enable debugging flags, run
+# "make BUILD_TYPE=Debug"
+ifeq "$(BUILD_TYPE)" ""
+BUILD_TYPE="Release"
+endif
+
+all: pod-build/Makefile
+	$(MAKE) -C pod-build all install
+
+pod-build/Makefile:
+	$(MAKE) configure
+
+.PHONY: configure
+configure:
+	@echo "\nBUILD_PREFIX: $(BUILD_PREFIX)\n\n"
+
+	# create the temporary build directory if needed
+	@mkdir -p pod-build
+
+	# run CMake to generate and configure the build scripts
+	@cd pod-build && cmake -DCMAKE_INSTALL_PREFIX=$(BUILD_PREFIX) \
+		   -DCMAKE_BUILD_TYPE=$(BUILD_TYPE) ..
+
+clean:
+	-if [ -e pod-build/install_manifest.txt ]; then rm -f `cat pod-build/install_manifest.txt`; fi
+	-if [ -d pod-build ]; then $(MAKE) -C pod-build clean; rm -rf pod-build; fi
+
+# other (custom) targets are passed through to the cmake-generated Makefile 
+%::
+	$(MAKE) -C pod-build $@
diff --git a/Makefile.bk b/Makefile.bk
new file mode 100644
index 000000000000..f3ea00a633bb
--- /dev/null
+++ b/Makefile.bk
@@ -0,0 +1,93 @@
+
+# Note: make will automatically delete intermediate files (google "make chains of implicit rules")
+
+CC = gcc
+CXX = g++
+PKG_CONFIG_PATH := ${PKG_CONFIG_PATH}:$(shell pwd)/thirdParty
+
+LCMFILES = $(shell find . -iname "*.lcm" | tr "\n" " " | sed "s|\./||g")
+SUBDIRS:=$(shell grep -v "^\#" tobuild.txt)
+
+LCM_CFILES = $(LCMFILES:%.lcm=%.c) 
+LCM_CFLAGS = $(shell pkg-config --cflags lcm)
+LCM_LDFLAGS = $(shell pkg-config --libs lcm)
+EIGEN_CFLAGS = $(shell pkg-config --cflags eigen3)
+
+#CFILES = $(LCM_CFILES)
+LCM_JAVAFILES = $(LCMFILES:%.lcm=%.java)
+OTHER_JAVAFILES = util/MyLCMTypeDatabase.java util/MessageMonitor.java util/CoordinateFrameData.java util/LCMCoder.java util/Transform.java
+JAVAFILES = $(LCM_JAVAFILES) $(OTHER_JAVAFILES)
+
+OBJFILES = $(LCM_CFILES:%.c=%.o) 
+CLASSFILES = $(JAVAFILES:%.java=%.class) 
+EXTRACLASSFILES = util/MyLCMTypeDatabase*MyClassVisitor.class
+
+MATLAB = $(shell which matlab)
+
+all: matlab_config java c
+	@for subdir in $(SUBDIRS); do \
+		echo "\n-------------------------------------------"; \
+		echo "-- $$subdir"; \
+		echo "-------------------------------------------"; \
+		$(MAKE) -C $$subdir all || exit 2; \
+	done
+
+debug: CXX += -g
+debug: CC += -g
+debug: matlab_config java c
+	@for subdir in $(SUBDIRS); do \
+		echo "\n-------------------------------------------"; \
+		echo "-- $$subdir"; \
+		echo "-------------------------------------------"; \
+		$(MAKE) -C $$subdir debug || exit 2; \
+	done
+
+doxygen :
+	doxygen doc/Doxyfile
+
+java : drake.jar
+
+c : drake.a 
+
+matlab_config : util/drake_config.mat .matlabroot
+
+util/drake_config.mat .matlabroot : configure.m
+	matlab -nosplash -nodesktop -r "configure;exit";
+# todo: consider using configure(struct('autoconfig',true))
+
+drake.jar : $(CLASSFILES)
+	cd ..; jar -cf drake/drake.jar $(CLASSFILES:%=drake/%) $(EXTRACLASSFILES:%=drake/%)
+
+drake.a : $(OBJFILES)
+	ar rc $@ $^
+
+.INTERMEDIATE : $(OBJFILES) $(CLASSFILES)
+.PRECIOUS : $(LCMFILES) $(OTHER_JAVAFILES)
+
+util/LCMCoder.class : util/LCMCoder.java util/CoordinateFrameData.class
+	javac $< -cp $(CLASSPATH):$(shell pwd)/../
+
+%.class : %.java
+	javac $<
+
+%.o : %.c
+	$(CC) -c -I include/ $< -o $@ $(LCM_CFLAGS) $(EIGEN_CFLAGS)
+
+%.c : %.lcm
+	@if grep -i package $< ; then echo "\n *** ERROR: $< has a package specified.  Don't do that. *** \n"; exit 1; fi
+	lcm-gen -c --c-cpath="$(shell echo $< | sed "s|/[A-Za-z0-9_]*\.lcm|/|")" --c-hpath="include/" $< 
+
+%.java : %.lcm
+	@if grep -i package $< ; then echo "\n *** ERROR: $< has a package specified.  Don't do that. *** \n"; exit 1; fi
+	lcm-gen -j --jdefaultpkg="drake.$(shell echo $< | sed "s|/[A-Za-z0-9._]*\.lcm||g" | tr "/" ".")" --jpath=".." $<
+
+clean : 
+	-rm -f drake.jar drake.a $(LIBS) $(LCM_HFILES) $(LCM_CFILES) $(OBJFILES) $(LCM_JAVAFILES) $(CLASSFILES) $(EXTRACLASSFILES)
+	-rm -rf doc/DoxygenMatlab/html 
+	@for subdir in $(SUBDIRS); do \
+		echo "\n-------------------------------------------"; \
+		echo "-- $$subdir"; \
+		echo "-------------------------------------------"; \
+		$(MAKE) -C $$subdir clean; \
+	done
+
diff --git a/algorithms/CMakeLists.txt b/algorithms/CMakeLists.txt
new file mode 100644
index 000000000000..0becd2fa2057
--- /dev/null
+++ b/algorithms/CMakeLists.txt
@@ -0,0 +1,3 @@
+cmake_minimum_required(VERSION 2.6.0)
+
+
diff --git a/algorithms/Makefile b/algorithms/Makefile.bk
similarity index 100%
rename from algorithms/Makefile
rename to algorithms/Makefile.bk
diff --git a/cmake/lcmtypes.cmake b/cmake/lcmtypes.cmake
new file mode 100644
index 000000000000..4f478af3b45a
--- /dev/null
+++ b/cmake/lcmtypes.cmake
@@ -0,0 +1,485 @@
+# Macros for automatically compiling LCM types into C, Java, and Python
+# libraries.
+#
+# The primary macro is:
+#     lcmtypes_build([C_AGGREGATE_HEADER header_fname] 
+#                    [C_LIBNAME lib_name]
+#                    [JAVA_DEST_DIR dir_name]
+#                    [PY_DEST_DIR dir_name]
+#                    )
+# 
+# It expects that the directory ${PROJECT_SOURCE_DIR}/lcmtypes contains all
+# the LCM types used by the system.  The macro generates C, Java, and Python
+# bindings.  See the C, Java, and Python sections below for information on
+# language specific options and generated results.
+#
+# After invoking this macro, the following variables will be set:
+#
+#   LCMTYPES_LIBS
+#   LCMTYPES_JAR
+#
+# 
+# C
+# ==
+# 
+# C bindings will be placed in ${PROJECT_SOURCE_DIR}/lcmtypes/c.  
+#
+# The autogenerated C bindings also get compiled to a static and shared
+# library.  The library prefix will be stored in LCMTYPES_LIBS on output.
+# This prefix can be manually set using the C_LIBNAME option.
+# 
+# Additionally, a header file will be generated that automatically includes
+# all of the other automatically generated header files.  The name of this
+# header file defaults to a cleaned-up version of "${PROJECT_NAME}.h" 
+# (non-alphanumeric characters replaced with underscores), but can
+# be manually set using the C_AGGREGATE_HEADER option.
+#
+# C++
+# ==
+# 
+# C++ bindings will be placed in ${PROJECT_SOURCE_DIR}/lcmtypes/cpp.
+#
+# The autogenerated CPP bindings are header only, so no library is created.
+# 
+# A header file will be generated that automatically includes
+# all of the other automatically generated header files.  The name of this
+# header file defaults to a cleaned-up version of "${PROJECT_NAME}.hpp" 
+# (non-alphanumeric characters replaced with underscores), but can
+# be manually set using the CPP_AGGREGATE_HEADER option.
+#
+#
+# Java
+# ====
+#
+# If Java is available, then Java bindings are be generated and placed in 
+#    ${PROJECT_SOURCE_DIR}/lcmtypes/java
+#
+# This directory can be changed using the JAVA_DEST_DIR option.
+# 
+# Additionally, targets are added to automatically compile the .java files to a
+# .jar file. The location of this jar file is stored in LCMTYPES_JAR
+#
+# and the .jar file will be installed to 
+#   ${CMAKE_INSTALL_PREFIX}/share/java
+#
+#
+# Python
+# ======
+#
+# If Python is enabled, then python bindings will be generated and placed in 
+#    ${PROJECT_SOURCE_DIR}/lcmtypes/python
+# 
+# This directory can be changed by setting the PY_DEST_DIR option.
+#
+# Additionally, the .py files will be installed to 
+#   ${CMAKE_INSTALL_PREFIX}/lib/python{X.Y}/dist-packages
+#   
+# where {X.Y} refers to the python version used to build the .py files.
+#
+# ----
+# File: lcmtypes.cmake
+# Distributed with pods version: 12.01.11
+
+cmake_minimum_required(VERSION 2.6.0)
+
+# Policy settings to prevent warnings on 2.6 but ensure proper operation on
+# 2.4.
+if(COMMAND cmake_policy)
+    # Logical target names must be globally unique.
+    cmake_policy(SET CMP0002 OLD)
+    # Libraries linked via full path no longer produce linker search paths.
+    cmake_policy(SET CMP0003 OLD)
+    # Preprocessor definition values are now escaped automatically.
+    cmake_policy(SET CMP0005 OLD)
+    if(POLICY CMP0011)
+        # Included scripts do automatic cmake_policy PUSH and POP.
+        cmake_policy(SET CMP0011 OLD)
+    endif(POLICY CMP0011)
+endif()
+
+macro(lcmtypes_get_types msgvar)
+    # get a list of all LCM types
+    file(GLOB __tmplcmtypes "${PROJECT_SOURCE_DIR}/lcmtypes/*.lcm")
+    set(${msgvar} "")
+    foreach(_msg ${__tmplcmtypes})
+        # Try to filter out temporary and backup files
+        if(${_msg} MATCHES "^[^\\.].*\\.lcm$")
+            list(APPEND ${msgvar} ${_msg})
+        endif(${_msg} MATCHES "^[^\\.].*\\.lcm$")
+    endforeach(_msg)
+endmacro()
+
+function(lcmgen)
+    execute_process(COMMAND ${LCM_GEN_EXECUTABLE} ${ARGV} RESULT_VARIABLE lcmgen_result)
+    if(NOT lcmgen_result EQUAL 0)
+        message(FATAL_ERROR "lcm-gen failed")
+    endif()
+endfunction()
+
+function(lcmtypes_add_clean_dir clean_dir)
+    get_directory_property(acfiles ADDITIONAL_MAKE_CLEAN_FILES)
+    list(APPEND acfiles ${clean_dir})
+    set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${acfiles}")
+endfunction()
+
+function(lcmtypes_build_c)
+    lcmtypes_get_types(_lcmtypes)
+    list(LENGTH _lcmtypes _num_lcmtypes)
+    if(_num_lcmtypes EQUAL 0)
+        return()
+    endif()
+
+    string(REGEX REPLACE "[^a-zA-Z0-9]" "_" __sanitized_project_name "${PROJECT_NAME}")
+
+    # set some defaults
+
+    # library name
+    set(libname "lcmtypes_${PROJECT_NAME}")
+
+    # header file that includes all other generated header files
+    set(agg_h_bname "${__sanitized_project_name}.h")
+
+    # allow defaults to be overriden by function parameters
+    set(modewords C_LIBNAME C_AGGREGATE_HEADER)
+    set(curmode "")
+    foreach(word ${ARGV})
+        list(FIND modewords ${word} mode_index)
+        if(${mode_index} GREATER -1)
+            set(curmode ${word})
+        elseif(curmode STREQUAL C_AGGREGATE_HEADER)
+            set(agg_h_bname "${word}")
+            set(curmode "")
+        elseif(curmode STREQUAL C_LIBNAME)
+            set(libname "${word}")
+            set(curmode "")
+        endif()
+    endforeach()
+
+    # generate C bindings for LCM types
+    set(_lcmtypes_c_dir ${PROJECT_SOURCE_DIR}/lcmtypes/c/lcmtypes)
+
+    # blow away any existing auto-generated files.
+    file(REMOVE_RECURSE ${_lcmtypes_c_dir})
+
+    # run lcm-gen now
+    execute_process(COMMAND mkdir -p ${_lcmtypes_c_dir})
+    lcmgen(--lazy -c --c-cpath ${_lcmtypes_c_dir} --c-hpath ${_lcmtypes_c_dir} --cinclude lcmtypes ${_lcmtypes})
+
+    # run lcm-gen at compile time
+    add_custom_target(lcmgen_c ALL 
+        COMMAND sh -c '[ -d ${_lcmtypes_c_dir} ] || mkdir -p ${_lcmtypes_c_dir}'
+        COMMAND sh -c '${LCM_GEN_EXECUTABLE} --lazy -c ${_lcmtypes} --c-cpath ${_lcmtypes_c_dir} --c-hpath ${_lcmtypes_c_dir}')
+
+    # get a list of all generated .c and .h files
+    file(GLOB _lcmtypes_c_files ${_lcmtypes_c_dir}/*.c)
+    file(GLOB _lcmtypes_h_files ${_lcmtypes_c_dir}/*.h)
+
+    include_directories(BEFORE ${PROJECT_SOURCE_DIR}/lcmtypes/c) #TODO: don't think this is necessary
+    include_directories(${LCM_INCLUDE_DIRS})
+
+    # aggregate into a static library
+    add_library(${libname} STATIC ${_lcmtypes_c_files})
+    set_source_files_properties(${_lcmtypes_c_files} PROPERTIES COMPILE_FLAGS "-fPIC")
+    #    set_target_properties("${libname}-static" PROPERTIES OUTPUT_NAME "${libname}")
+    set_target_properties(${libname} PROPERTIES PREFIX "lib")
+    set_target_properties(${libname} PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+    add_dependencies(${libname} lcmgen_c)
+
+    #    add_library("${libname}-static" STATIC ${_lcmtypes_c_files})
+    #    set_source_files_properties(${_lcmtypes_c_files} PROPERTIES COMPILE_FLAGS "-I${PROJECT_SOURCE_DIR}/lcmtypes/c")
+    #    set_target_properties("${libname}-static" PROPERTIES OUTPUT_NAME "${libname}")
+    #    set_target_properties("${libname}-static" PROPERTIES PREFIX "lib")
+    #    set_target_properties("${libname}-static" PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+    #    add_dependencies("${libname}-static" lcmgen_c)
+
+    # XXX don't build a shared library, as it makes using 3rd-party/external
+    # LCM types awkward (linker will try to link external symbols at library link time, 
+    # rather than executable link time)
+
+    #    # aggregate into a shared library
+    #    add_library(${libname} SHARED ${_lcmtypes_c_files})
+    #    set_target_properties("${libname}" PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+    #    add_dependencies("${libname}" lcmgen_c)
+    #    target_link_libraries(${libname} ${LCM_LDFLAGS})
+
+    # create a header file aggregating all of the autogenerated .h files
+    set(__agg_h_fname "${_lcmtypes_c_dir}/${agg_h_bname}")
+    file(WRITE ${__agg_h_fname}
+        "#ifndef __lcmtypes_${__sanitized_project_name}_h__\n"
+        "#define __lcmtypes_${__sanitized_project_name}_h__\n\n")
+    foreach(h_file ${_lcmtypes_h_files})
+        file(RELATIVE_PATH __tmp_path ${_lcmtypes_c_dir} ${h_file})
+        file(APPEND ${__agg_h_fname} "#include \"${__tmp_path}\"\n")
+    endforeach()
+    file(APPEND ${__agg_h_fname} "\n#endif\n")
+    list(APPEND _lcmtypes_h_files ${__agg_h_fname})
+    unset(__sanitized_project_name)
+    unset(__agg_h_fname)
+
+    # make header files and libraries public
+    pods_install_libraries(${libname})
+    pods_install_headers(${_lcmtypes_h_files} DESTINATION lcmtypes)
+
+    # set some compilation variables
+    set(LCMTYPES_LIBS ${libname} PARENT_SCOPE)
+
+    # create a pkg-config file
+  	pods_install_pkg_config_file(${libname}
+    	CFLAGS
+    	DESCRIPTION "LCM types for ${PROJECT_NAME}"
+        LIBS -l${libname}
+    	REQUIRES lcm
+    	VERSION 0.0.0)
+  
+    lcmtypes_add_clean_dir("${PROJECT_SOURCE_DIR}/lcmtypes/c")
+endfunction()
+
+function(lcmtypes_build_cpp)
+    lcmtypes_get_types(_lcmtypes)
+    list(LENGTH _lcmtypes _num_lcmtypes)
+    if(_num_lcmtypes EQUAL 0)
+        return()
+    endif()
+
+    string(REGEX REPLACE "[^a-zA-Z0-9]" "_" __sanitized_project_name "${PROJECT_NAME}")
+
+    # set some defaults
+
+    # header file that includes all other generated header files
+    set(agg_hpp_bname "${__sanitized_project_name}.hpp")
+
+    # allow defaults to be overriden by function parameters
+    set(modewords CPP_AGGREGATE_HEADER)
+    set(curmode "")
+    foreach(word ${ARGV})
+        list(FIND modewords ${word} mode_index)
+        if(${mode_index} GREATER -1)
+            set(curmode ${word})
+        elseif(curmode STREQUAL CPP_AGGREGATE_HEADER)
+            set(agg_hpp_bname "${word}")
+            set(curmode "")
+        endif()
+    endforeach()
+
+    # generate CPP bindings for LCM types
+    set(_lcmtypes_cpp_dir ${PROJECT_SOURCE_DIR}/lcmtypes/cpp/lcmtypes)
+
+    # blow away any existing auto-generated files.
+    file(REMOVE_RECURSE ${_lcmtypes_cpp_dir})
+
+    # run lcm-gen now
+    execute_process(COMMAND mkdir -p ${_lcmtypes_cpp_dir})
+    lcmgen(--lazy --cpp --cpp-cpath ${_lcmtypes_cpp_dir} --cpp-hpath ${_lcmtypes_cpp_dir} --cpp-include lcmtypes ${_lcmtypes})
+
+    # run lcm-gen at compile time
+    add_custom_target(lcmgen_cpp ALL 
+        COMMAND sh -c '[ -d ${_lcmtypes_cpp_dir} ] || mkdir -p ${_lcmtypes_cpp_dir}'
+        COMMAND sh -c '${LCM_GEN_EXECUTABLE} --lazy --cpp ${_lcmtypes} --cpp-cpath ${_lcmtypes_cpp_dir} --cpp-hpath ${_lcmtypes_cpp_dir}')
+
+    # get a list of all generated .hpp files
+    file(GLOB_RECURSE _lcmtypes_hpp_files  ${_lcmtypes_cpp_dir}/*.hpp)
+    
+    include_directories(BEFORE ${PROJECT_SOURCE_DIR}/lcmtypes/cpp) #TODO: don't think this is necessary
+    include_directories(${LCM_INCLUDE_DIRS})
+
+    # create a header file aggregating all of the autogenerated .hpp files
+    set(__agg_hpp_fname "${_lcmtypes_cpp_dir}/${agg_hpp_bname}")
+    file(WRITE ${__agg_hpp_fname}
+        "#ifndef __lcmtypes_${__sanitized_project_name}_hpp__\n"
+        "#define __lcmtypes_${__sanitized_project_name}_hpp__\n\n")
+    foreach(hpp_file ${_lcmtypes_hpp_files})
+        file(RELATIVE_PATH __tmp_path ${_lcmtypes_cpp_dir} ${hpp_file})
+        file(APPEND ${__agg_hpp_fname} "#include \"${__tmp_path}\"\n")
+        get_filename_component(__tmp_dir ${__tmp_path} PATH)
+        pods_install_headers(${hpp_file} DESTINATION lcmtypes/${__tmp_dir})
+    endforeach()
+    file(APPEND ${__agg_hpp_fname} "\n#endif\n")
+    pods_install_headers(${__agg_hpp_fname} DESTINATION lcmtypes)
+    unset(__sanitized_project_name)
+    unset(__agg_hpp_fname)
+
+ 
+
+    lcmtypes_add_clean_dir("${PROJECT_SOURCE_DIR}/lcmtypes/cpp")
+endfunction()
+
+function(lcmtypes_build_java)
+    lcmtypes_get_types(_lcmtypes)
+    list(LENGTH _lcmtypes _num_lcmtypes)
+    if(_num_lcmtypes EQUAL 0)
+        return()
+    endif()
+
+    # do we have Java?
+    find_package(Java)
+    if(JAVA_COMPILE STREQUAL JAVA_COMPILE-NOTFOUND OR
+       JAVA_ARCHIVE STREQUAL JAVA_ARCHIVE-NOTFOUND)
+        message(STATUS "Not building Java LCM type bindings (Can't find Java)")
+        return()
+    endif()
+
+    # do we have LCM java bindings?  where is lcm.jar?
+    execute_process(COMMAND pkg-config --variable=classpath lcm-java OUTPUT_VARIABLE LCM_JAR_FILE)
+    if(NOT LCM_JAR_FILE)
+        message(STATUS "Not building Java LCM type bindings (Can't find lcm.jar)")
+        return()
+    endif()
+    string(STRIP ${LCM_JAR_FILE} LCM_JAR_FILE)
+    set(LCMTYPES_JAR ${CMAKE_CURRENT_BINARY_DIR}/lcmtypes_${PROJECT_NAME}.jar)
+
+    # generate Java bindings for LCM types
+    set(_lcmtypes_java_dir ${PROJECT_SOURCE_DIR}/lcmtypes/java)
+    set(auto_manage_files YES)
+
+    set(modewords JAVA_DEST_DIR)
+    set(curmode "")
+    foreach(word ${ARGV})
+        list(FIND modewords ${word} mode_index)
+        if(${mode_index} GREATER -1)
+            set(curmode ${word})
+        elseif(curmode STREQUAL JAVA_DEST_DIR)
+            set(_lcmtypes_java_dir "${word}")
+            set(auto_manage_files NO)
+            set(curmode "")
+        endif()
+    endforeach()
+
+    # blow away any existing auto-generated files?
+    if(auto_manage_files)
+        file(REMOVE_RECURSE ${_lcmtypes_java_dir})
+    endif()
+
+    # run lcm-gen now
+    execute_process(COMMAND mkdir -p ${_lcmtypes_java_dir})
+    lcmgen(--lazy -j ${_lcmtypes} --jpath ${_lcmtypes_java_dir})
+
+    # run lcm-gen at compile time
+    add_custom_target(lcmgen_java ALL
+        COMMAND sh -c '[ -d ${_lcmtypes_java_dir} ] || mkdir -p ${_lcmtypes_java_dir}'
+        COMMAND sh -c '${LCM_GEN_EXECUTABLE} --lazy -j ${_lcmtypes} --jpath ${_lcmtypes_java_dir}')
+
+    if(NOT auto_manage_files)
+        return()
+    endif()
+
+    # get a list of all generated .java files
+    file(GLOB_RECURSE _lcmtypes_java_files ${_lcmtypes_java_dir}/*.java)
+
+    set(java_classpath ${_lcmtypes_java_dir}:${LCM_JAR_FILE})
+
+    # search for lcmtypes_*.jar files in well-known places and add them to the
+    # classpath
+    foreach(pfx /usr /usr/local ${CMAKE_INSTALL_PREFIX})
+        file(GLOB_RECURSE jarfiles ${pfx}/share/java/lcmtypes_*.jar)
+        foreach(jarfile ${jarfiles})
+            set(java_classpath ${java_classpath}:${jarfile})
+            #            message("found ${jarfile}")
+        endforeach()
+    endforeach()
+
+    # convert the list of .java filenames to a list of .class filenames
+    foreach(javafile ${_lcmtypes_java_files})
+        string(REPLACE .java .class __tmp_class_fname ${javafile})
+        #        add_custom_command(OUTPUT ${__tmp_class_fname} COMMAND
+        #            ${JAVA_COMPILE} -source 6 -cp ${_lcmtypes_java_dir}:${lcm_jar} ${javafile} VERBATIM DEPENDS ${javafile})
+        list(APPEND _lcmtypes_class_files ${__tmp_class_fname})
+        unset(__tmp_class_fname)
+    endforeach()
+
+    # add a rule to build the .class files from from the .java files
+    add_custom_command(OUTPUT ${_lcmtypes_class_files} COMMAND 
+        ${JAVA_COMPILE} -source 6 -cp ${java_classpath} ${_lcmtypes_java_files} 
+        DEPENDS ${_lcmtypes_java_files} VERBATIM)
+
+    # add a rule to build a .jar file from the .class files
+    add_custom_command(OUTPUT lcmtypes_${PROJECT_NAME}.jar COMMAND
+        ${JAVA_ARCHIVE} cf ${LCMTYPES_JAR} -C ${_lcmtypes_java_dir} . DEPENDS ${_lcmtypes_class_files} VERBATIM)
+    add_custom_target(lcmtypes_${PROJECT_NAME}_jar ALL DEPENDS ${LCMTYPES_JAR})
+
+    add_dependencies(lcmtypes_${PROJECT_NAME}_jar lcmgen_java)
+
+    install(FILES ${LCMTYPES_JAR} DESTINATION share/java)
+    set(LCMTYPES_JAR ${LCMTYPES_JAR} PARENT_SCOPE)
+
+    lcmtypes_add_clean_dir(${_lcmtypes_java_dir})
+endfunction()
+
+function(lcmtypes_build_python)
+    lcmtypes_get_types(_lcmtypes)
+    list(LENGTH _lcmtypes _num_lcmtypes)
+    if(_num_lcmtypes EQUAL 0)
+        return()
+    endif()
+
+    find_package(PythonInterp)
+    if(NOT PYTHONINTERP_FOUND)
+        message(STATUS "Not building Python LCM type bindings (Can't find Python)")
+        return()
+    endif()
+
+    set(_lcmtypes_python_dir ${PROJECT_SOURCE_DIR}/lcmtypes/python)
+    set(auto_manage_files YES)
+
+    set(modewords PY_DEST_DIR)
+    set(curmode "")
+    foreach(word ${ARGV})
+        list(FIND modewords ${word} mode_index)
+        if(${mode_index} GREATER -1)
+            set(curmode ${word})
+        elseif(curmode STREQUAL PY_DEST_DIR)
+            set(_lcmtypes_python_dir "${word}")
+            set(auto_manage_files NO)
+            set(curmode "")
+        endif()
+    endforeach()
+
+    # purge existing files?
+    if(auto_manage_files)
+        file(REMOVE_RECURSE ${_lcmtypes_python_dir})
+    endif()
+
+    # generate Python bindings for LCM types
+    execute_process(COMMAND mkdir -p ${_lcmtypes_python_dir})
+    execute_process(COMMAND ${LCM_GEN_EXECUTABLE} --lazy -p ${_lcmtypes} --ppath ${_lcmtypes_python_dir})
+
+    # run lcm-gen at compile time
+    add_custom_target(lcmgen_python ALL
+        COMMAND sh -c '${LCM_GEN_EXECUTABLE} --lazy -p ${_lcmtypes} --ppath ${_lcmtypes_python_dir}')
+
+    if(NOT auto_manage_files)
+        return()
+    endif()
+    
+    pods_install_python_packages(${_lcmtypes_python_dir})
+
+    lcmtypes_add_clean_dir(${_lcmtypes_python_dir})
+endfunction()
+
+function(lcmtypes_install_types)
+    lcmtypes_get_types(_lcmtypes)
+    list(LENGTH _lcmtypes _num_lcmtypes)
+    if(_num_lcmtypes EQUAL 0)
+        return()
+    endif()
+
+    install(FILES ${_lcmtypes} DESTINATION share/lcmtypes)
+endfunction()
+
+macro(lcmtypes_build)
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(LCM REQUIRED lcm)
+    
+    #find lcm-gen (it may be in the install path)
+    find_program(LCM_GEN_EXECUTABLE lcm-gen ${EXECUTABLE_OUTPUT_PATH} ${EXECUTABLE_INSTALL_PATH})
+    if (NOT LCM_GEN_EXECUTABLE)
+    	message(FATAL_ERROR "lcm-gen not found!\n")
+    	return()
+    endif()
+    
+    lcmtypes_build_c(${ARGV})
+    lcmtypes_build_cpp(${ARGV})
+
+    lcmtypes_build_java(${ARGV})
+    lcmtypes_build_python(${ARGV})
+    lcmtypes_install_types()
+endmacro()
diff --git a/cmake/pods.cmake b/cmake/pods.cmake
new file mode 100644
index 000000000000..6fa026f08d3d
--- /dev/null
+++ b/cmake/pods.cmake
@@ -0,0 +1,412 @@
+# Macros to simplify compliance with the pods build policies.
+#
+# To enable the macros, add the following lines to CMakeLists.txt:
+#   set(POD_NAME <pod-name>)
+#   include(cmake/pods.cmake)
+#
+# If POD_NAME is not set, then the CMake source directory is used as POD_NAME
+#
+# Next, any of the following macros can be used.  See the individual macro
+# definitions in this file for individual documentation.
+#
+# C/C++
+#   pods_install_headers(...)
+#   pods_install_libraries(...)
+#   pods_install_executables(...)
+#   pods_install_pkg_config_file(...)
+#
+#   pods_use_pkg_config_packages(...)
+#
+# Python
+#   pods_install_python_packages(...)
+#   pods_install_python_script(...)
+#
+# Java
+#   None yet
+#
+# ----
+# File: pods.cmake
+# Distributed with pods version: 12.11.14
+
+# pods_install_headers(<header1.h> ... DESTINATION <subdir_name>)
+# 
+# Install a (list) of header files.
+#
+# Header files will all be installed to include/<subdir_name>
+#
+# example:
+#   add_library(perception detector.h sensor.h)
+#   pods_install_headers(detector.h sensor.h DESTINATION perception)
+#
+function(pods_install_headers)
+    list(GET ARGV -2 checkword)
+    if(NOT checkword STREQUAL DESTINATION)
+        message(FATAL_ERROR "pods_install_headers missing DESTINATION parameter")
+    endif()
+
+    list(GET ARGV -1 dest_dir)
+    list(REMOVE_AT ARGV -1)
+    list(REMOVE_AT ARGV -1)
+    #copy the headers to the INCLUDE_OUTPUT_PATH (${CMAKE_BINARY_DIR}/include)
+    foreach(header ${ARGV})
+        get_filename_component(_header_name ${header} NAME)
+        configure_file(${header} ${INCLUDE_OUTPUT_PATH}/${dest_dir}/${_header_name} COPYONLY)
+	endforeach(header)
+	#mark them to be installed
+	install(FILES ${ARGV} DESTINATION include/${dest_dir})
+
+
+endfunction(pods_install_headers)
+
+# pods_install_executables(<executable1> ...)
+#
+# Install a (list) of executables to bin/
+function(pods_install_executables)
+    install(TARGETS ${ARGV} RUNTIME DESTINATION bin)
+endfunction(pods_install_executables)
+
+# pods_install_libraries(<library1> ...)
+#
+# Install a (list) of libraries to lib/
+function(pods_install_libraries)
+    install(TARGETS ${ARGV} LIBRARY DESTINATION lib ARCHIVE DESTINATION lib)
+endfunction(pods_install_libraries)
+
+
+# pods_install_pkg_config_file(<package-name> 
+#                              [VERSION <version>]
+#                              [DESCRIPTION <description>]
+#                              [CFLAGS <cflag> ...]
+#                              [LIBS <lflag> ...]
+#                              [REQUIRES <required-package-name> ...])
+# 
+# Create and install a pkg-config .pc file.
+#
+# example:
+#    add_library(mylib mylib.c)
+#    pods_install_pkg_config_file(mylib LIBS -lmylib REQUIRES glib-2.0)
+function(pods_install_pkg_config_file)
+    list(GET ARGV 0 pc_name)
+    # TODO error check
+    
+    set(pc_version 0.0.1)
+    set(pc_description ${pc_name})
+    set(pc_requires "")
+    set(pc_libs "")
+    set(pc_cflags "")
+    set(pc_fname "${PKG_CONFIG_OUTPUT_PATH}/${pc_name}.pc")
+    
+    set(modewords LIBS CFLAGS REQUIRES VERSION DESCRIPTION)
+    set(curmode "")
+
+    # parse function arguments and populate pkg-config parameters
+    list(REMOVE_AT ARGV 0)
+    foreach(word ${ARGV})
+        list(FIND modewords ${word} mode_index)
+        if(${mode_index} GREATER -1)
+            set(curmode ${word})
+        elseif(curmode STREQUAL LIBS)
+            set(pc_libs "${pc_libs} ${word}")
+        elseif(curmode STREQUAL CFLAGS)
+            set(pc_cflags "${pc_cflags} ${word}")
+        elseif(curmode STREQUAL REQUIRES)
+            set(pc_requires "${pc_requires} ${word}")
+        elseif(curmode STREQUAL VERSION)
+            set(pc_version ${word})
+            set(curmode "")
+        elseif(curmode STREQUAL DESCRIPTION)
+            set(pc_description "${word}")
+            set(curmode "")
+        else(${mode_index} GREATER -1)
+            message("WARNING incorrect use of pods_add_pkg_config (${word})")
+            break()
+        endif(${mode_index} GREATER -1)
+    endforeach(word)
+
+    # write the .pc file out
+    file(WRITE ${pc_fname}
+        "prefix=${CMAKE_INSTALL_PREFIX}\n"
+        "exec_prefix=\${prefix}\n"
+        "libdir=\${exec_prefix}/lib\n"
+        "includedir=\${prefix}/include\n"
+        "\n"
+        "Name: ${pc_name}\n"
+        "Description: ${pc_description}\n"
+        "Requires: ${pc_requires}\n"
+        "Version: ${pc_version}\n"
+        "Libs: -L\${libdir} ${pc_libs}\n"
+        "Cflags: -I\${includedir} ${pc_cflags}\n")
+
+    # mark the .pc file for installation to the lib/pkgconfig directory
+    install(FILES ${pc_fname} DESTINATION lib/pkgconfig)
+    
+endfunction(pods_install_pkg_config_file)
+
+
+# pods_install_python_script(<script_name> <python_module_or_file>)
+#
+# Create and install a script that invokes the python interpreter with a
+# specified python module or script.
+#
+# A launcher script will be installed to bin/<script_name>. The script simply
+# adds <install-prefix>/lib/pythonX.Y/dist-packages
+# and  <install-prefix>/lib/pythonX.Y/site-packages 
+# to the PYTHONPATH, and then 
+# invokes `python -m <python_module>` or `python python_file` 
+# depending on whether the function was passed a module name or script file.
+#
+# example:
+#    pods_install_python_script(run-py-module py_pkg.py_module)
+#    pods_install_python_script(run-py-script py_script.py)
+function(pods_install_python_script script_name python_module_or_file)
+    find_package(PythonInterp REQUIRED)
+
+    # which python version?
+    execute_process(COMMAND 
+        ${PYTHON_EXECUTABLE} -c "import sys; sys.stdout.write(sys.version[:3])"
+        OUTPUT_VARIABLE pyversion)
+
+    # where do we install .py files to?
+    set(python_install_dir 
+        ${CMAKE_INSTALL_PREFIX}/lib/python${pyversion}/dist-packages)
+    set(python_old_install_dir #todo: when do we get rid of this? 
+        ${CMAKE_INSTALL_PREFIX}/lib/python${pyversion}/site-packages)
+        
+    if (python_module_or_file MATCHES ".+\\.py") #ends with a .py
+        get_filename_component(py_file ${python_module_or_file} ABSOLUTE)     
+            
+        if (NOT EXISTS ${py_file})
+            message(FATAL_ERROR "${python_module_or_file} is not an absolute or relative path to a python script")
+        endif()
+        
+        #get the directory where we'll install the script ${sanitized_POD_NAME}_scripts
+        string(REGEX REPLACE "[^a-zA-Z0-9]" "_" __sanitized_pod_name "${POD_NAME}")
+        set(pods_scripts_dir "${python_install_dir}/${__sanitized_pod_name}_scripts")
+                
+        # install the python script file
+        install(FILES ${py_file}  DESTINATION "${pods_scripts_dir}")
+
+        get_filename_component(py_script_name ${py_file} NAME)
+        # write the bash script file
+        file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${script_name} 
+            "#!/bin/sh\n"
+            "export PYTHONPATH=${python_install_dir}:${python_old_install_dir}:\${PYTHONPATH}\n"
+            "exec ${PYTHON_EXECUTABLE} ${pods_scripts_dir}/${py_script_name} $*\n")    
+    else()
+        get_filename_component(py_module ${python_module_or_file} NAME) #todo: check whether module exists?
+        # write the bash script file
+        file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${script_name} 
+            "#!/bin/sh\n"
+            "export PYTHONPATH=${python_install_dir}:${python_old_install_dir}:\${PYTHONPATH}\n"
+            "exec ${PYTHON_EXECUTABLE} -m ${py_module} $*\n")
+    endif()
+    # install it...
+    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${script_name} DESTINATION bin)
+endfunction()
+
+# _pods_install_python_package(<py_src_dir> <py_module_name>)
+#
+# Internal helper function
+# Install python module in <py_src_dir> to lib/pythonX.Y/dist-packages/<py_module_name>,
+# where X.Y refers to the current python version (e.g., 2.6)
+#
+function(_pods_install_python_package py_src_dir py_module_name)
+    find_package(PythonInterp REQUIRED)
+    # which python version?
+    execute_process(COMMAND 
+        ${PYTHON_EXECUTABLE} -c "import sys; sys.stdout.write(sys.version[:3])"
+        OUTPUT_VARIABLE pyversion)
+
+    # where do we install .py files to?
+    set(python_install_dir 
+        ${CMAKE_INSTALL_PREFIX}/lib/python${pyversion}/dist-packages)
+
+    if(EXISTS "${py_src_dir}/__init__.py")
+        #install the single module
+        file(GLOB_RECURSE module_files   ${py_src_dir}/*)
+        foreach(file ${module_files})
+            if(NOT file MATCHES ".*\\.svn.*|.*\\.pyc|.*[~#]")
+                file(RELATIVE_PATH __tmp_path ${py_src_dir} ${file})
+                get_filename_component(__tmp_dir ${__tmp_path} PATH)
+                install(FILES ${file}
+                    DESTINATION "${python_install_dir}/${py_module_name}/${__tmp_dir}")
+            endif()
+        endforeach()
+    else()
+        message(FATAL_ERROR "${py_src_dir} is not a python package!\n")
+    endif()
+endfunction()
+
+
+# pods_install_python_packages(<src_dir1> ...)
+#
+# Install python packages to lib/pythonX.Y/dist-packages, where X.Y refers to
+# the current python version (e.g., 2.6)
+#
+# For each <src_dir> pass in, it will do the following:
+# If <src_dir> is a python package (it has a __init__.py file) it will be installed 
+# along with any .py files in subdirectories
+#
+# Otherwise the script searches for and installs any python packages in <src_dir>
+function(pods_install_python_packages py_src_dir)
+    get_filename_component(py_src_abs_dir ${py_src_dir} ABSOLUTE)
+    if(ARGC GREATER 1)
+        #install each module seperately 
+        foreach(py_module ${ARGV}) 
+            pods_install_python_packages(${py_module})
+        endforeach()
+    elseif(EXISTS "${py_src_abs_dir}/__init__.py")
+        #install the single module by name
+        get_filename_component(py_module_name ${py_src_abs_dir} NAME) 
+        _pods_install_python_package(${py_src_abs_dir} ${py_module_name})            
+    else()
+        # install any packages within the passed in py_src_dir 
+        set(_installed_a_package FALSE)
+        file(GLOB sub-dirs RELATIVE ${py_src_abs_dir} ${py_src_abs_dir}/*)
+        foreach(sub-dir ${sub-dirs})
+            if(EXISTS "${py_src_abs_dir}/${sub-dir}/__init__.py")
+                _pods_install_python_package(${py_src_abs_dir}/${sub-dir} ${sub-dir})
+                set(_installed_a_package TRUE)
+            endif()
+        endforeach()
+        if (NOT _installed_a_package)
+            message(FATAL_ERROR "${py_src_dir} does not contain any python packages!\n")
+        endif()
+    endif()
+endfunction()
+
+
+# pods_use_pkg_config_packages(<target> <package-name> ...)
+#
+# Convenience macro to get compiler and linker flags from pkg-config and apply them
+# to the specified target.
+#
+# Invokes `pkg-config --cflags-only-I <package-name> ...` and adds the result to the
+# include directories.
+#
+# Additionally, invokes `pkg-config --libs <package-name> ...` and adds the result to
+# the target's link flags (via target_link_libraries)
+#
+# example:
+#   add_executable(myprogram main.c)
+#   pods_use_pkg_config_packages(myprogram glib-2.0 opencv)
+macro(pods_use_pkg_config_packages target)
+    if(${ARGC} LESS 2)
+        message(WARNING "Useless invocation of pods_use_pkg_config_packages")
+        return()
+    endif()
+    find_package(PkgConfig REQUIRED)
+    execute_process(COMMAND 
+        ${PKG_CONFIG_EXECUTABLE} --cflags-only-I ${ARGN}
+        OUTPUT_VARIABLE _pods_pkg_include_flags)
+    string(STRIP ${_pods_pkg_include_flags} _pods_pkg_include_flags)
+    string(REPLACE "-I" "" _pods_pkg_include_flags "${_pods_pkg_include_flags}")
+	separate_arguments(_pods_pkg_include_flags)
+    #    message("include: ${_pods_pkg_include_flags}")
+    execute_process(COMMAND 
+        ${PKG_CONFIG_EXECUTABLE} --libs ${ARGN}
+        OUTPUT_VARIABLE _pods_pkg_ldflags)
+    string(STRIP ${_pods_pkg_ldflags} _pods_pkg_ldflags)
+    #    message("ldflags: ${_pods_pkg_ldflags}")
+    include_directories(${_pods_pkg_include_flags})
+    target_link_libraries(${target} ${_pods_pkg_ldflags})
+    
+    # make the target depend on libraries that are cmake targets
+    if (_pods_pkg_ldflags)
+        string(REPLACE " " ";" _split_ldflags ${_pods_pkg_ldflags})
+        foreach(__ldflag ${_split_ldflags})
+                string(REGEX REPLACE "^-l" "" __depend_target_name ${__ldflag})
+                get_target_property(IS_TARGET ${__depend_target_name} LOCATION)
+                if (NOT IS_TARGET STREQUAL "IS_TARGET-NOTFOUND")
+                    #message("---- ${target} depends on  ${libname}")
+                    add_dependencies(${target} ${__depend_target_name})
+                endif() 
+        endforeach()
+    endif()
+
+    unset(_split_ldflags)
+    unset(_pods_pkg_include_flags)
+    unset(_pods_pkg_ldflags)
+endmacro()
+
+
+# pods_config_search_paths()
+#
+# Setup include, linker, and pkg-config paths according to the pods core
+# policy.  This macro is automatically invoked, there is no need to do so
+# manually.
+macro(pods_config_search_paths)
+    if(NOT DEFINED __pods_setup)
+		#set where files should be output locally
+	    set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib)
+	    set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin)
+	    set(INCLUDE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/include)
+	    set(PKG_CONFIG_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib/pkgconfig)
+		
+		#set where files should be installed to
+	    set(LIBRARY_INSTALL_PATH ${CMAKE_INSTALL_PREFIX}/lib)
+	    set(EXECUTABLE_INSTALL_PATH ${CMAKE_INSTALL_PREFIX}/bin)
+	    set(INCLUDE_INSTALL_PATH ${CMAKE_INSTALL_PREFIX}/include)
+	    set(PKG_CONFIG_INSTALL_PATH ${CMAKE_INSTALL_PREFIX}/lib/pkgconfig)
+
+
+        # add build/lib/pkgconfig to the pkg-config search path
+        set(ENV{PKG_CONFIG_PATH} ${PKG_CONFIG_INSTALL_PATH}:$ENV{PKG_CONFIG_PATH})
+        set(ENV{PKG_CONFIG_PATH} ${PKG_CONFIG_OUTPUT_PATH}:$ENV{PKG_CONFIG_PATH})
+
+        # add build/include to the compiler include path
+        include_directories(BEFORE ${INCLUDE_OUTPUT_PATH})
+        include_directories(${INCLUDE_INSTALL_PATH})
+
+        # add build/lib to the link path
+        link_directories(${LIBRARY_OUTPUT_PATH})
+        link_directories(${LIBRARY_INSTALL_PATH})
+        
+
+        # abuse RPATH
+        if(${CMAKE_INSTALL_RPATH})
+            set(CMAKE_INSTALL_RPATH ${LIBRARY_INSTALL_PATH}:${CMAKE_INSTALL_RPATH})
+        else(${CMAKE_INSTALL_RPATH})
+            set(CMAKE_INSTALL_RPATH ${LIBRARY_INSTALL_PATH})
+        endif(${CMAKE_INSTALL_RPATH})
+
+        # for osx, which uses "install name" path rather than rpath
+        #set(CMAKE_INSTALL_NAME_DIR ${LIBRARY_OUTPUT_PATH})
+        set(CMAKE_INSTALL_NAME_DIR ${CMAKE_INSTALL_RPATH})
+        
+        # hack to force cmake always create install and clean targets 
+        install(FILES DESTINATION)
+        string(RANDOM LENGTH 32 __rand_target__name__)
+        add_custom_target(${__rand_target__name__})
+        unset(__rand_target__name__)
+
+        set(__pods_setup true)
+    endif(NOT DEFINED __pods_setup)
+endmacro(pods_config_search_paths)
+
+macro(enforce_out_of_source)
+    if(CMAKE_BINARY_DIR STREQUAL PROJECT_SOURCE_DIR)
+      message(FATAL_ERROR 
+      "\n
+      Do not run cmake directly in the pod directory. 
+      use the supplied Makefile instead!  You now need to
+      remove CMakeCache.txt and the CMakeFiles directory.
+
+      Then to build, simply type: 
+       $ make
+      ")
+    endif()
+endmacro(enforce_out_of_source)
+
+#set the variable POD_NAME to the directory path, and set the cmake PROJECT_NAME
+if(NOT POD_NAME)
+    get_filename_component(POD_NAME ${CMAKE_SOURCE_DIR} NAME)
+    message(STATUS "POD_NAME is not set... Defaulting to directory name: ${POD_NAME}") 
+endif(NOT POD_NAME)
+project(${POD_NAME})
+
+#make sure we're running an out-of-source build
+enforce_out_of_source()
+
+#call the function to setup paths
+pods_config_search_paths()
diff --git a/systems/plants/viewer/lcmt_robot_state.lcm b/lcmtypes/lcmt_robot_state.lcm
similarity index 95%
rename from systems/plants/viewer/lcmt_robot_state.lcm
rename to lcmtypes/lcmt_robot_state.lcm
index c65008c43119..1bd078fd5793 100644
--- a/systems/plants/viewer/lcmt_robot_state.lcm
+++ b/lcmtypes/lcmt_robot_state.lcm
@@ -1,3 +1,4 @@
+package drake;
 
 struct lcmt_robot_state
 {
diff --git a/systems/plants/viewer/lcmt_viewer_command.lcm b/lcmtypes/lcmt_viewer_command.lcm
similarity index 96%
rename from systems/plants/viewer/lcmt_viewer_command.lcm
rename to lcmtypes/lcmt_viewer_command.lcm
index 3013eb6515d3..925ef81a6ff8 100644
--- a/systems/plants/viewer/lcmt_viewer_command.lcm
+++ b/lcmtypes/lcmt_viewer_command.lcm
@@ -1,3 +1,4 @@
+package drake;
 
 struct lcmt_viewer_command
 {
diff --git a/systems/CMakeLists.txt b/systems/CMakeLists.txt
new file mode 100644
index 000000000000..5002ba0de377
--- /dev/null
+++ b/systems/CMakeLists.txt
@@ -0,0 +1,4 @@
+cmake_minimum_required(VERSION 2.6.0)
+
+add_subdirectory(plants)
+
diff --git a/systems/Makefile b/systems/Makefile.bk
similarity index 100%
rename from systems/Makefile
rename to systems/Makefile.bk
diff --git a/systems/plants/CMakeLists.txt b/systems/plants/CMakeLists.txt
new file mode 100644
index 000000000000..f96be8d9c911
--- /dev/null
+++ b/systems/plants/CMakeLists.txt
@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 2.6.0)
+
+pods_install_headers(RigidBodyManipulator.h RigidBody.h URDFRigidBodyManipulator.h DESTINATION plants)
+
+add_library(RigidBodyManipulator RigidBodyManipulator.cpp)
+add_library(URDFRigidBodyManipulator URDFRigidBodyManipulator.cpp)
+target_link_libraries(URDFRigidBodyManipulator RigidBodyManipulator urdf_interface tinyxml)
+
+add_subdirectory(urdf_interface)
+add_subdirectory(viewer)
+
+
+pods_use_pkg_config_packages(RigidBodyManipulator
+  eigen3)
+
+pods_use_pkg_config_packages(URDFRigidBodyManipulator
+  bot2-vis  
+  eigen3)
diff --git a/systems/plants/Makefile b/systems/plants/Makefile.bk
similarity index 100%
rename from systems/plants/Makefile
rename to systems/plants/Makefile.bk
diff --git a/systems/plants/urdf.cpp b/systems/plants/URDFRigidBodyManipulator.cpp
similarity index 99%
rename from systems/plants/urdf.cpp
rename to systems/plants/URDFRigidBodyManipulator.cpp
index b3eb05e96a66..735a41dafb9b 100644
--- a/systems/plants/urdf.cpp
+++ b/systems/plants/URDFRigidBodyManipulator.cpp
@@ -5,7 +5,7 @@
 #include <sstream>
 #include <map>
 
-#include "urdf.h"
+#include "URDFRigidBodyManipulator.h"
 
 
 #ifdef BOT_VIS_SUPPORT
diff --git a/systems/plants/urdf.h b/systems/plants/URDFRigidBodyManipulator.h
similarity index 100%
rename from systems/plants/urdf.h
rename to systems/plants/URDFRigidBodyManipulator.h
diff --git a/systems/plants/tinyxml/CMakeLists.txt b/systems/plants/tinyxml/CMakeLists.txt
new file mode 100644
index 000000000000..e8f7e80161b0
--- /dev/null
+++ b/systems/plants/tinyxml/CMakeLists.txt
@@ -0,0 +1,4 @@
+cmake_minimum_required(VERSION 2.6.0)
+
+add_library(tinyxml tinyxml.cpp tinyxmlparser.cpp tinyxmlerror.cpp)
+
diff --git a/systems/plants/tinyxml/Makefile b/systems/plants/tinyxml/Makefile.bk
similarity index 100%
rename from systems/plants/tinyxml/Makefile
rename to systems/plants/tinyxml/Makefile.bk
diff --git a/systems/plants/urdf_interface/CMakeLists.txt b/systems/plants/urdf_interface/CMakeLists.txt
new file mode 100644
index 000000000000..a1e18722f31e
--- /dev/null
+++ b/systems/plants/urdf_interface/CMakeLists.txt
@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 2.6.0)
+
+find_package( Boost REQUIRED  )
+include_directories ( ${Boost_INCLUDE_DIR} )
+
+add_library(urdf_interface joint.cpp link.cpp)
+
diff --git a/systems/plants/urdf_interface/Makefile b/systems/plants/urdf_interface/Makefile.bk
similarity index 100%
rename from systems/plants/urdf_interface/Makefile
rename to systems/plants/urdf_interface/Makefile.bk
diff --git a/systems/plants/urdf_interface/joint.cpp b/systems/plants/urdf_interface/joint.cpp
index 906ae4f210d9..9de929b134c7 100644
--- a/systems/plants/urdf_interface/joint.cpp
+++ b/systems/plants/urdf_interface/joint.cpp
@@ -35,9 +35,11 @@
 /* Author: John Hsu */
 
 #include <sstream>
-#include <urdf_interface/joint.h>
 #include <boost/lexical_cast.hpp>
-#include <urdf_interface/exceptions.h>
+
+#include "exceptions.h"
+#include "joint.h"
+
 
 namespace urdf{
 
diff --git a/systems/plants/urdf_interface/link.cpp b/systems/plants/urdf_interface/link.cpp
index 5fa2e9f5fa8c..02418ab03c38 100644
--- a/systems/plants/urdf_interface/link.cpp
+++ b/systems/plants/urdf_interface/link.cpp
@@ -35,12 +35,13 @@
 /* Author: Wim Meeussen */
 
 
-#include <urdf_interface/link.h>
 #include <fstream>
 #include <sstream>
 #include <boost/lexical_cast.hpp>
 #include <algorithm>
-#include <urdf_interface/exceptions.h>
+
+#include "link.h"
+#include "exceptions.h"
 
 namespace urdf{
 
diff --git a/systems/plants/urdf_interface/pose.h b/systems/plants/urdf_interface/pose.h
index 2c2a90378f8a..2fdc7df4382e 100644
--- a/systems/plants/urdf_interface/pose.h
+++ b/systems/plants/urdf_interface/pose.h
@@ -43,7 +43,7 @@
 #include <math.h>
 #include <boost/algorithm/string.hpp>
 #include <boost/lexical_cast.hpp>
-#include <urdf_interface/exceptions.h>
+#include "exceptions.h"
 
 #include <tinyxml.h> // FIXME: remove parser from here
 
diff --git a/systems/plants/viewer/CMakeLists.txt b/systems/plants/viewer/CMakeLists.txt
new file mode 100644
index 000000000000..0a46e8bfdd3d
--- /dev/null
+++ b/systems/plants/viewer/CMakeLists.txt
@@ -0,0 +1,17 @@
+cmake_minimum_required (VERSION 2.6)
+
+add_executable(drake_viewer main.cpp)
+# add_executable(lcmgl_test lcmgl_test.cpp)
+
+find_package( Boost REQUIRED filesystem system )
+
+include_directories ( ${Boost_INCLUDE_DIR} )
+link_directories( ${Boost_LIBRARY_DIRS} )
+
+add_library(drake_urdf_renderer drake_urdf_renderer.cpp)
+target_link_libraries(drake_viewer drake_urdf_renderer lcmtypes_drake RigidBodyManipulator URDFRigidBodyManipulator urdf_interface ${Boost_LIBRARIES})
+
+pods_use_pkg_config_packages(drake_viewer
+  bot2-vis  
+  bot2-lcmgl-renderer
+  eigen3)
diff --git a/systems/plants/viewer/Makefile b/systems/plants/viewer/Makefile.bk
similarity index 100%
rename from systems/plants/viewer/Makefile
rename to systems/plants/viewer/Makefile.bk
diff --git a/systems/plants/viewer/drake_urdf_renderer.cpp b/systems/plants/viewer/drake_urdf_renderer.cpp
index f0837096cd29..9c76bda9192b 100644
--- a/systems/plants/viewer/drake_urdf_renderer.cpp
+++ b/systems/plants/viewer/drake_urdf_renderer.cpp
@@ -5,10 +5,9 @@
 
 #include <boost/shared_ptr.hpp>
 
-#include <urdf.h>
+#include "plants/URDFRigidBodyManipulator.h"
 
-#include <lcmt_viewer_command.h>
-#include <lcmt_robot_state.h>
+#include "lcmtypes/drake.h"
 
 #include "drake_urdf_renderer.h"
 
@@ -188,12 +187,12 @@ static void my_draw( BotViewer *viewer, BotRenderer *renderer )
 
 
 static void handle_lcm_viewer_command(const lcm_recv_buf_t *rbuf, const char * channel, 
-        const lcmt_viewer_command * msg, void * user)
+        const drake_lcmt_viewer_command * msg, void * user)
 {
   RendererData *self = (RendererData*) user;
   
   switch(msg->command_type) {
-    case LCMT_VIEWER_COMMAND_LOAD_URDF:
+    case DRAKE_LCMT_VIEWER_COMMAND_LOAD_URDF:
       {
         if (self->model) delete self->model;
         cout << "loading urdf: " << msg->command_data << endl;
@@ -205,13 +204,13 @@ static void handle_lcm_viewer_command(const lcm_recv_buf_t *rbuf, const char * c
       }
       break;
 
-    case LCMT_VIEWER_COMMAND_LOAD_TERRAIN:
+    case DRAKE_LCMT_VIEWER_COMMAND_LOAD_TERRAIN:
       {
       	cerr << "Terrain loading from file not implemented yet" << endl;
       }
     	break;
 
-    case LCMT_VIEWER_COMMAND_SET_TERRAIN_TRANSFORM:
+    case DRAKE_LCMT_VIEWER_COMMAND_SET_TERRAIN_TRANSFORM:
 			{
       	cerr << "Setting the terrain transform is not implemented yet" << endl;
 			}
@@ -226,7 +225,7 @@ static void handle_lcm_viewer_command(const lcm_recv_buf_t *rbuf, const char * c
 }
 
 static void handle_lcm_robot_state(const lcm_recv_buf_t *rbuf, const char * channel, 
-        const lcmt_robot_state * msg, void * user)
+        const drake_lcmt_robot_state * msg, void * user)
 {
   RendererData *self = (RendererData*) user;
   
@@ -299,16 +298,16 @@ drake_urdf_add_renderer_to_viewer(BotViewer* viewer, lcm_t* lcm, int priority)
   renderer->enabled = 1;
   renderer->user = self;
   
-  lcmt_viewer_command_subscribe(lcm,"DRAKE_VIEWER_COMMAND",&handle_lcm_viewer_command,self);
-  lcmt_robot_state_subscribe(lcm,"DRAKE_VIEWER_STATE",&handle_lcm_robot_state,self);
+  drake_lcmt_viewer_command_subscribe(lcm,"DRAKE_VIEWER_COMMAND",&handle_lcm_viewer_command,self);
+  drake_lcmt_robot_state_subscribe(lcm,"DRAKE_VIEWER_STATE",&handle_lcm_robot_state,self);
   
   bot_viewer_add_renderer(viewer, renderer, priority);
 
-  lcmt_viewer_command status_message;
-  status_message.command_type = LCMT_VIEWER_COMMAND_STATUS;
+  drake_lcmt_viewer_command status_message;
+  status_message.command_type = DRAKE_LCMT_VIEWER_COMMAND_STATUS;
   status_message.command_data = (char*) "loaded";
 
-  lcmt_viewer_command_publish(lcm, "DRAKE_VIEWER_STATUS", &status_message);
+  drake_lcmt_viewer_command_publish(lcm, "DRAKE_VIEWER_STATUS", &status_message);
 }
 
 /*
diff --git a/tobuild.txt b/tobuild.txt
deleted file mode 100644
index af554d135dbc..000000000000
--- a/tobuild.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-
-util
-algorithms
-systems
-#thirdParty/GetFullPath
-
diff --git a/util/CMakeLists.txt b/util/CMakeLists.txt
new file mode 100644
index 000000000000..0becd2fa2057
--- /dev/null
+++ b/util/CMakeLists.txt
@@ -0,0 +1,3 @@
+cmake_minimum_required(VERSION 2.6.0)
+
+
diff --git a/util/Makefile b/util/Makefile.bk
similarity index 100%
rename from util/Makefile
rename to util/Makefile.bk