diff --git a/include/fc/rpc/binary_api_connection.hpp b/include/fc/rpc/binary_api_connection.hpp
new file mode 100644
index 0000000..9c9ce2f
--- /dev/null
+++ b/include/fc/rpc/binary_api_connection.hpp
@@ -0,0 +1,532 @@
+#pragma once
+#include <fc/variant.hpp>
+#include <fc/io/raw.hpp>
+#include <fc/optional.hpp>
+#include <fc/api.hpp>
+#include <fc/any.hpp>
+#include <memory>
+#include <vector>
+#include <functional>
+#include <utility>
+#include <fc/signals.hpp>
+//#include <fc/rpc/json_connection.hpp>
+
+namespace fc {
+   class binary_api_connection;
+
+   namespace detail {
+      template<typename Signature>
+      class callback_functor
+      {
+         public:
+            typedef typename std::function<Signature>::result_type result_type;
+
+            callback_functor( std::weak_ptr< fc::binary_api_connection > con, uint64_t id )
+            :_callback_id(id),_binary_api_connection(con){}
+
+            template<typename... Args> 
+            result_type operator()( Args... args )const;
+
+         private:
+            uint64_t _callback_id;
+            std::weak_ptr< fc::binary_api_connection > _binary_api_connection;
+      };
+
+      template<typename R, typename Arg0, typename ... Args>
+      std::function<R(Args...)> bind_first_arg( const std::function<R(Arg0,Args...)>& f, Arg0 a0 )
+      {
+         return [=]( Args... args ) { return f( a0, args... ); };
+      }
+      template<typename R>
+      R call_generic( const std::function<R()>& f, variants::const_iterator a0, variants::const_iterator e )
+      {
+         return f();
+      }
+
+      template<typename R, typename Arg0, typename ... Args>
+      R call_generic( const std::function<R(Arg0,Args...)>& f, variants::const_iterator a0, variants::const_iterator e )
+      {
+         FC_ASSERT( a0 != e );
+         return  call_generic<R,Args...>( bind_first_arg<R,Arg0,Args...>( f, a0->as< typename std::decay<Arg0>::type >() ), a0+1, e );
+      }
+
+      template<typename R, typename ... Args>
+      std::function<variant(const fc::variants&)> to_generic( const std::function<R(Args...)>& f )
+      {
+         return [=]( const variants& args ) { 
+            return variant( call_generic( f, args.begin(), args.end() ) ); 
+         };
+      }
+
+      template<typename ... Args>
+      std::function<variant(const fc::variants&)> to_generic( const std::function<void(Args...)>& f )
+      {
+         return [=]( const variants& args ) { 
+            call_generic( f, args.begin(), args.end() ); 
+            return variant();
+         };
+      }
+
+      /**
+       * If api<T> is returned from a remote method, the API is eagerly bound to api<T> of
+       * the correct type in api_visitor::from_variant().  This binding [1] needs a reference
+       * to the binary_api_connection, which is made available to from_variant() as a parameter.
+       *
+       * However, in the case of a remote method which returns api_base which can subsequently
+       * be cast by the caller with as<T>, we need to keep track of the connection because
+       * the binding is done later (when the client code actually calls as<T>).
+       *
+       * [1] The binding actually happens in get_remote_api().
+       */
+      class any_api : public api_base
+      {
+         public:
+            any_api( api_id_type api_id, const std::shared_ptr<fc::binary_api_connection>& con )
+               : _api_id(api_id), _binary_api_connection(con) {}
+
+            virtual uint64_t get_handle()const override
+            {  return _api_id;    }
+
+            virtual api_id_type register_api( binary_api_connection& conn )const override
+            {  FC_ASSERT( false ); return api_id_type(); }
+
+            api_id_type                         _api_id;
+            std::weak_ptr<fc::binary_api_connection>   _binary_api_connection;
+      };
+
+   } // namespace detail
+
+   class generic_api
+   {
+      public:
+         template<typename Api>
+         generic_api( const Api& a, const std::shared_ptr<fc::binary_api_connection>& c );
+
+         generic_api( const generic_api& cpy ) = delete;
+
+         vector<char> call( const string& name, const vector<char>& args )
+         {
+            auto itr = _by_name.find(name);
+            FC_ASSERT( itr != _by_name.end(), "no method with name '${name}'", ("name",name)("api",_by_name) );
+            return call( itr->second, args );
+         }
+
+         vector<char> call( uint32_t method_id, const vector<char>& args )
+         {
+            FC_ASSERT( method_id < _methods.size() );
+            return _methods[method_id](args);
+         }
+
+         std::weak_ptr< fc::binary_api_connection > get_connection()
+         {
+            return _binary_api_connection;
+         }
+
+         std::vector<std::string> get_method_names()const
+         {
+            std::vector<std::string> result;
+            result.reserve( _by_name.size() );
+            for( auto& m : _by_name ) result.push_back(m.first);
+            return result;
+         }
+
+      private:
+         friend struct api_visitor;
+
+         template<typename R, typename Arg0, typename ... Args>
+         std::function<R(Args...)> bind_first_arg( const std::function<R(Arg0,Args...)>& f, Arg0 a0 )const
+         {
+            return [=]( Args... args ) { return f( a0, args... ); };
+         }
+
+         template<typename R>
+         R call_generic( const std::function<R()>& f, datastream<const char*>& ds )const
+         {
+            return f();
+         }
+
+         template<typename R, typename Signature, typename ... Args>
+         R call_generic( const std::function<R(std::function<Signature>,Args...)>& f, datastream<const char*>& ds )
+         {
+            uint64_t callback_id = 0;
+            fc::raw::unpack( ds, callback_id );
+            detail::callback_functor<Signature> arg0( get_connection(), callback_id );
+            return  call_generic<R,Args...>( this->bind_first_arg<R,std::function<Signature>,Args...>( f, std::function<Signature>(arg0) ), ds );
+         }
+         template<typename R, typename Signature, typename ... Args>
+         R call_generic( const std::function<R(const std::function<Signature>&,Args...)>& f, fc::datastream<const char*>& ds )
+         {
+            uint64_t callback_id = 0;
+            fc::raw::unpack( ds, callback_id );
+            detail::callback_functor<Signature> arg0( get_connection(), callback_id );
+            return  call_generic<R,Args...>( this->bind_first_arg<R,const std::function<Signature>&,Args...>( f, arg0 ), ds );
+         }
+
+         template<typename R, typename Arg0, typename ... Args>
+         R call_generic( const std::function<R(Arg0,Args...)>& f, fc::datastream<const char*>& ds )
+         {
+            std::decay<Arg0>::type a0;
+            fc::raw::unpack( ds, a0 );
+            return  call_generic<R,Args...>( this->bind_first_arg<R,Arg0,Args...>( f, a0 ), ds );
+         }
+
+         struct api_visitor
+         {
+            api_visitor( generic_api& a, const std::weak_ptr<fc::binary_api_connection>& s ):api(a),_api_con(s){ }
+
+            template<typename Interface, typename Adaptor, typename ... Args>
+            std::function<variant(const fc::variants&)> to_generic( const std::function<api<Interface,Adaptor>(Args...)>& f )const;
+
+            template<typename Interface, typename Adaptor, typename ... Args>
+            std::function<variant(const fc::variants&)> to_generic( const std::function<fc::optional<api<Interface,Adaptor>>(Args...)>& f )const;
+
+            template<typename ... Args>
+            std::function<variant(const fc::variants&)> to_generic( const std::function<fc::api_ptr(Args...)>& f )const;
+
+            template<typename R, typename ... Args>
+            std::function<variant(const fc::variants&)> to_generic( const std::function<R(Args...)>& f )const;
+
+            template<typename ... Args>
+            std::function<variant(const fc::variants&)> to_generic( const std::function<void(Args...)>& f )const;
+
+            template<typename Result, typename... Args>
+            void operator()( const char* name, std::function<Result(Args...)>& memb )const {
+               api._methods.emplace_back( to_generic( memb ) ); 
+               api._by_name[name] = api._methods.size() - 1;
+            }
+
+            generic_api&  api;
+            const std::weak_ptr<fc::binary_api_connection>& _api_con;
+         };
+
+
+         std::weak_ptr<fc::binary_api_connection>                         _binary_api_connection;
+         fc::any                                                          _api;
+         std::map< std::string, uint32_t >                                _by_name;
+         std::vector< std::function<vector<char>(const vector<char>&)> >  _methods;
+   }; // class generic_api
+
+
+
+   class binary_api_connection : public std::enable_shared_from_this<fc::binary_api_connection>
+   {
+      public:
+         typedef std::vector<char> params_type;
+         typedef std::vector<char> result_type;
+
+         binary_api_connection(){}
+         virtual ~binary_api_connection(){};
+
+
+         template<typename T>
+         api<T> get_remote_api( api_id_type api_id = 0 )
+         {
+            api<T> result;
+            result->visit( api_visitor(  api_id, this->shared_from_this() ) );
+            return result;
+         }
+  
+         /** makes calls to the remote server */
+         virtual result_type send_call( api_id_type api_id, string method_name, params_type args = params_type() ) = 0;
+         virtual result_type send_callback( uint64_t callback_id, params_type args = params_type() ) = 0;
+         virtual void    send_notice( uint64_t callback_id, params_type args = params_type() ) = 0;
+
+         result_type receive_call( api_id_type api_id, const string& method_name, const params_type& args = params_type() )const
+         {
+            FC_ASSERT( _local_apis.size() > api_id );
+            return _local_apis[api_id]->call( method_name, args );
+         }
+         result_type receive_callback( uint64_t callback_id,  const params_type& args = params_type() )const
+         {
+            FC_ASSERT( _local_callbacks.size() > callback_id );
+            return _local_callbacks[callback_id]( args );
+         }
+         void receive_notice( uint64_t callback_id,  const params_type& args = params_type() )const
+         {
+            FC_ASSERT( _local_callbacks.size() > callback_id );
+            _local_callbacks[callback_id]( args );
+         }
+
+         template<typename Interface>
+         api_id_type register_api( const Interface& a )
+         {
+            auto handle = a.get_handle();
+            auto itr = _handle_to_id.find(handle);
+            if( itr != _handle_to_id.end() ) return itr->second;
+
+            _local_apis.push_back( std::unique_ptr<generic_api>( new generic_api(a, shared_from_this() ) ) );
+            _handle_to_id[handle] = _local_apis.size() - 1;
+            return _local_apis.size() - 1;
+         }
+
+         template<typename Signature>
+         uint64_t register_callback( const std::function<Signature>& cb )
+         {
+            _local_callbacks.push_back( detail::to_generic( cb ) );
+            return _local_callbacks.size() - 1;
+         }
+
+         std::vector<std::string> get_method_names( api_id_type local_api_id = 0 )const { return _local_apis[local_api_id]->get_method_names(); }
+
+         fc::signal<void()> closed;
+      private:
+         std::vector< std::unique_ptr<generic_api> >             _local_apis;
+         std::map< uint64_t, api_id_type >                       _handle_to_id;
+         std::vector< std::function<variant(const variants&)>  > _local_callbacks;
+
+
+         struct api_visitor
+         {
+            uint32_t                            _api_id;
+            std::shared_ptr<fc::binary_api_connection> _connection;
+
+            api_visitor( uint32_t api_id, std::shared_ptr<fc::binary_api_connection> con )
+            :_api_id(api_id),_connection(std::move(con))
+            {
+            }
+
+            api_visitor() = delete;
+
+            template<typename Result>
+            static Result from_vector( const vector<char>& v, Result*, const std::shared_ptr<fc::binary_api_connection>&  )
+            {
+               return fc::raw::unpack<Result>( v ); 
+            }
+
+            template<typename ResultInterface>
+            static fc::api<ResultInterface> from_vector( const vector<char>& v, 
+                                                          fc::api<ResultInterface>* /*used for template deduction*/,
+                                                          const std::shared_ptr<fc::binary_api_connection>&  con 
+                                                        )
+            {
+               return con->get_remote_api<ResultInterface>( fc::raw::unpack<uint64_t>( v ) );
+            }
+
+            static fc::api_ptr from_vector(
+               const vector<char>& v,
+               fc::api_ptr* /* used for template deduction */,
+               const std::shared_ptr<fc::binary_api_connection>&  con
+            )
+            {
+               return fc::api_ptr( new detail::any_api( fc::raw::unpack<uint64_t>(v), con ) );
+            }
+
+            template<typename T>
+            static result_type convert_callbacks( const std::shared_ptr<fc::binary_api_connection>&, const T& v ) 
+            { 
+               return fc::raw::pack(v); 
+            }
+
+            template<typename Signature>
+            static result_type convert_callbacks( const std::shared_ptr<fc::binary_api_connection>& con, const std::function<Signature>& v ) 
+            { 
+               return con->register_callback( v ); 
+            }
+
+            template<typename Result, typename... Args>
+            void operator()( const char* name, std::function<Result(Args...)>& memb )const 
+            {
+                auto con   = _connection;
+                auto api_id = _api_id;
+                memb = [con,api_id,name]( Args... args ) {
+                    auto var_result = con->send_call( api_id, name, { convert_callbacks(con,args)...} );
+                    return from_vector( var_result, (Result*)nullptr, con );
+                };
+            }
+            template<typename... Args>
+            void operator()( const char* name, std::function<void(Args...)>& memb )const 
+            {
+                auto con   = _connection;
+                auto api_id = _api_id;
+                memb = [con,api_id,name]( Args... args ) {
+                   con->send_call( api_id, name, { convert_callbacks(con,args)...} );
+                };
+            }
+         };
+   };
+
+   class local_binary_api_connection : public binary_api_connection
+   {
+      public:
+         /** makes calls to the remote server */
+         virtual result_type send_call( api_id_type api_id, string method_name, params_type args = params_type() ) override
+         {
+            FC_ASSERT( _remote_connection );
+            return _remote_connection->receive_call( api_id, method_name, std::move(args) );
+         }
+         virtual result_type send_callback( uint64_t callback_id, params_type args = params_type() ) override
+         {
+            FC_ASSERT( _remote_connection );
+            return _remote_connection->receive_callback( callback_id, args );
+         }
+         virtual void send_notice( uint64_t callback_id, params_type args = params_type() ) override
+         {
+            FC_ASSERT( _remote_connection );
+            _remote_connection->receive_notice( callback_id, args );
+         }
+
+
+         void  set_remote_connection( const std::shared_ptr<fc::binary_api_connection>& rc )
+         {
+            FC_ASSERT( !_remote_connection );
+            FC_ASSERT( rc != this->shared_from_this() );
+            _remote_connection = rc;
+         }
+         const std::shared_ptr<fc::binary_api_connection>& remote_connection()const  { return _remote_connection; }
+
+         std::shared_ptr<fc::binary_api_connection>    _remote_connection;
+   };
+
+   template<typename Api>
+   generic_api::generic_api( const Api& a, const std::shared_ptr<fc::binary_api_connection>& c )
+   :_binary_api_connection(c),_api(a)
+   {
+      boost::any_cast<const Api&>(a)->visit( api_visitor( *this, c ) );
+   }
+
+   template<typename Interface, typename Adaptor, typename ... Args>
+   std::function<result_type(const params_type&)> generic_api::api_visitor::to_generic( 
+                                               const std::function<fc::api<Interface,Adaptor>(Args...)>& f )const
+   {
+      auto api_con = _api_con;
+      auto gapi = &api;
+      return [=]( const params_type& args ) { 
+         auto con = api_con.lock();
+         FC_ASSERT( con, "not connected" );
+
+         fc::raw::datastream<const char*> ds( args.data(), args.size() );
+         auto api_result = gapi->call_generic( f, args ); 
+         return con->register_api( api_result );
+      };
+   }
+   template<typename Interface, typename Adaptor, typename ... Args>
+   std::function<result_type(const params_type&)> generic_api::api_visitor::to_generic( 
+                                               const std::function<fc::optional<fc::api<Interface,Adaptor>>(Args...)>& f )const
+   {
+      auto api_con = _api_con;
+      auto gapi = &api;
+      return [=]( const params_type& args )-> fc::variant { 
+         auto con = api_con.lock();
+         FC_ASSERT( con, "not connected" );
+
+         fc::raw::datastream<const char*> ds( args.data(), args.size() );
+         auto api_result = gapi->call_generic( f, ds ); 
+         if( api_result )
+            return con->register_api( *api_result );
+         return result_type();
+      };
+   }
+
+   template<typename ... Args>
+   std::function<result_type(const params_type&)> generic_api::api_visitor::to_generic(
+                                               const std::function<fc::api_ptr(Args...)>& f )const
+   {
+      auto api_con = _api_con;
+      auto gapi = &api;
+      return [=]( const variants& args ) -> fc::variant {
+         auto con = api_con.lock();
+         FC_ASSERT( con, "not connected" );
+
+         fc::raw::datastream<const char*> ds( args.data(), args.size() );
+         auto api_result = gapi->call_generic( f, ds );
+         if( !api_result )
+            return result_type();
+         return api_result->register_api( *con );
+      };
+   }
+
+   template<typename R, typename ... Args>
+   std::function<result_type(const params_type&)> generic_api::api_visitor::to_generic( const std::function<R(Args...)>& f )const
+   {
+      generic_api* gapi = &api;
+      return [f,gapi]( const params_type& args ) { 
+         fc::raw::datastream<const char*> ds( args.data(), args.size() );
+         return  fc::raw::pack(gapi->call_generic( f, ds )); 
+      };
+   }
+
+   template<typename ... Args>
+   std::function<result_type(const params_type&)> generic_api::api_visitor::to_generic( const std::function<void(Args...)>& f )const
+   {
+      generic_api* gapi = &api;
+      return [f,gapi]( const params_type& args ) { 
+         fc::raw::datastream<const char*> ds( args.data(), args.size() );
+         gapi->call_generic( f, ds ); 
+         return result_type();
+      };
+   }
+
+   /**
+    * It is slightly unclean tight coupling to have this method in the api class.
+    * It breaks encapsulation by requiring an api class method to have a pointer
+    * to an binary_api_connection.  The reason this is necessary is we have a goal of being
+    * able to call register_api() on an api<T> through its base class api_base.  But
+    * register_api() must know the template parameters!
+    *
+    * The only reasonable way to achieve the goal is to implement register_api()
+    * as a method in api<T> (which obviously knows the template parameter T),
+    * then make the implementation accessible through the base class (by making
+    * it a pure virtual method in the base class which is overridden by the subclass's
+    * implementation).
+    */
+   template< typename Interface, typename Transform >
+   api_id_type api< Interface, Transform >::register_api( binary_api_connection& conn )const
+   {
+      return conn.register_api( *this );
+   }
+
+   template< typename T >
+   api<T> api_base::as()
+   {
+      // TODO:  this method should probably be const (if it is not too hard)
+      api<T>* maybe_requested_type = dynamic_cast< api<T>* >(this);
+      if( maybe_requested_type != nullptr )
+         return *maybe_requested_type;
+
+      detail::any_api* maybe_any = dynamic_cast< detail::any_api* >(this);
+      FC_ASSERT( maybe_any != nullptr );
+      std::shared_ptr< binary_api_connection > api_conn = maybe_any->_binary_api_connection.lock();
+      FC_ASSERT( api_conn );
+      return api_conn->get_remote_api<T>( maybe_any->_api_id );
+   }
+
+   namespace detail {
+      template<typename Signature>
+      template<typename... Args> 
+      typename callback_functor<Signature>::result_type callback_functor<Signature>::operator()( Args... args )const
+      {
+         std::shared_ptr< fc::binary_api_connection > locked = _binary_api_connection.lock();
+         // TODO:  make new exception type for this instead of recycling eof_exception
+         if( !locked )
+            throw fc::eof_exception();
+
+         /// TODO------------->>> pack args... 
+         locked->send_callback( _callback_id, fc::raw::pack( args... ) ).template as< result_type >();
+      }
+
+
+      template<typename... Args>
+      class callback_functor<void(Args...)>
+      {
+         public:
+          typedef void result_type;
+
+          callback_functor( std::weak_ptr< fc::binary_api_connection > con, uint64_t id )
+          :_callback_id(id),_binary_api_connection(con){}
+
+          void operator()( Args... args )const
+          {
+             std::shared_ptr< fc::binary_api_connection > locked = _binary_api_connection.lock();
+             // TODO:  make new exception type for this instead of recycling eof_exception
+             if( !locked )
+                throw fc::eof_exception();
+             locked->send_notice( _callback_id, fc::variants{ args... } );
+          }
+
+         private:
+          uint64_t _callback_id;
+          std::weak_ptr< fc::binary_api_connection > _binary_api_connection;
+      };
+   } // namespace detail
+
+} // fc