133 files changed, 879 insertions, 953 deletions

diff --git a/src/archive.h b/src/archive.h
index 9d2aee2..5294c15 100644
--- a/src/archive.h
+++ b/src/archive.h
@@ -111,7 +111,7 @@ namespace Bu
                 void readID( const void *ptr, uint32_t id );
 
                 template<typename t>
-                void setProp( const Bu::FString &sId, const t &val )
+                void setProp( const Bu::String &sId, const t &val )
                 {
                         if( !hProps.has( sId ) )
                         {
@@ -121,7 +121,7 @@ namespace Bu
                 }
 
                 template<typename t>
-                t getProp( const Bu::FString &sId )
+                t getProp( const Bu::String &sId )
                 {
                         return hProps.get( sId );
                 }
@@ -131,7 +131,7 @@ namespace Bu
                 uint32_t nNextID;
                 Hash<uint32_t,uint32_t> hPtrID;
                 Hash<uint32_t,List<void **> > hPtrDest;
-                Hash<Bu::FString, Variant> hProps;
+                Hash<Bu::String, Variant> hProps;
         };
 }
 
diff --git a/src/bitstring.cpp b/src/bitstring.cpp
index 207a036..39c2e63 100644
--- a/src/bitstring.cpp
+++ b/src/bitstring.cpp
@@ -444,9 +444,9 @@ long Bu::BitString::getHighestOrderBitPos()
         return -1;
 }
 
-Bu::FString Bu::BitString::toString()
+Bu::String Bu::BitString::toString()
 {
-        Bu::FString sRet;
+        Bu::String sRet;
         for( int j = iBits-1; j >= 0; j-- )
                 sRet.append( getBit( j )?'1':'0' );
         return sRet;
diff --git a/src/bitstring.h b/src/bitstring.h
index 4d0437a..a8aec57 100644
--- a/src/bitstring.h
+++ b/src/bitstring.h
@@ -9,7 +9,7 @@
 #define BU_BITSTRING_H
 
 #include "bu/util.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 namespace Bu
 {
@@ -203,7 +203,7 @@ namespace Bu
                  */
                 long toLong( long iStart = 0, long iSize = 32 );
 
-                Bu::FString toString();
+                Bu::String toString();
 
                 //operators
                 BitString &operator=( const BitString &xSrc );
diff --git a/src/cachestorefiles.h b/src/cachestorefiles.h
index c2cf091..5a9478d 100644
--- a/src/cachestorefiles.h
+++ b/src/cachestorefiles.h
@@ -8,7 +8,7 @@
 #ifndef BU_CACHE_STORE_FILES_H
 #define BU_CACHE_STORE_FILES_H
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/file.h"
 #include "bu/cachestore.h"
 #include "bu/archive.h"
@@ -53,7 +53,7 @@ namespace Bu
         class CacheStoreFiles : public CacheStore<keytype, obtype>
         {
         public:
-                CacheStoreFiles( const Bu::FString &sPrefix ) :
+                CacheStoreFiles( const Bu::String &sPrefix ) :
                         sPrefix( sPrefix )
                 {
                         if( access( sPrefix.getStr(), W_OK|R_OK|X_OK ) )
@@ -138,7 +138,7 @@ namespace Bu
                         Bu::MemBuf mb;
                         Bu::Formatter f( mb );
                         f << sPrefix << "/";
-                        Bu::FString sBase = mb.getString();
+                        Bu::String sBase = mb.getString();
                         f << key;
 
                         if( sBase == mb.getString() )
@@ -199,7 +199,7 @@ namespace Bu
                 }
 
         private:
-                Bu::FString sPrefix;
+                Bu::String sPrefix;
         };
 
 };
diff --git a/src/cachestoremyriad.h b/src/cachestoremyriad.h
index 21c84e6..1928840 100644
--- a/src/cachestoremyriad.h
+++ b/src/cachestoremyriad.h
@@ -8,7 +8,7 @@
 #ifndef BU_CACHE_STORE_MYRIAD_H
 #define BU_CACHE_STORE_MYRIAD_H
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/stream.h"
 #include "bu/myriad.h"
 #include "bu/cachestore.h"
diff --git a/src/client.cpp b/src/client.cpp
index b635c8b..c8d5dd4 100644
--- a/src/client.cpp
+++ b/src/client.cpp
@@ -109,12 +109,12 @@ void Bu::Client::clearProtocol()
         pProto = NULL;
 }
 /*
-Bu::FString &Bu::Client::getInput()
+Bu::String &Bu::Client::getInput()
 {
         return sReadBuf;
 }
 
-Bu::FString &Bu::Client::getOutput()
+Bu::String &Bu::Client::getOutput()
 {
         return sWriteBuf;
 }
@@ -126,7 +126,7 @@ bool Bu::Client::isOpen()
         return pTopStream->isOpen();
 }
 
-size_t Bu::Client::write( const Bu::FString &sData )
+size_t Bu::Client::write( const Bu::String &sData )
 {
         return qbWrite.write( sData.getStr(), sData.getSize() );
 }
@@ -221,7 +221,7 @@ Bu::ClientLink *Bu::Client::getLink()
         return pfLink->createLink( this );
 }
 
-void Bu::Client::onMessage( const Bu::FString &sMsg )
+void Bu::Client::onMessage( const Bu::String &sMsg )
 {
         if( pProto )
                 pProto->onMessage( this, sMsg );
diff --git a/src/client.h b/src/client.h
index 98b31f7..871acad 100644
--- a/src/client.h
+++ b/src/client.h
@@ -11,7 +11,7 @@
 #include <stdint.h>
 
 #include "bu/config.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/queuebuf.h"
 
 namespace Bu
@@ -33,9 +33,9 @@ namespace Bu
                 void processInput();
                 void processOutput();
 
-                //Bu::FString &getInput();
-                //Bu::FString &getOutput();
-                size_t write( const Bu::FString &sData );
+                //Bu::String &getInput();
+                //Bu::String &getOutput();
+                size_t write( const Bu::String &sData );
                 size_t write( const void *pData, size_t nBytes );
                 size_t write( int8_t nData );
                 size_t write( int16_t nData );
@@ -66,7 +66,7 @@ namespace Bu
 
                 class ClientLink *getLink();
 
-                void onMessage( const Bu::FString &sMsg );
+                void onMessage( const Bu::String &sMsg );
 
                 bool hasOutput() { return qbWrite.getSize() > 0; }
                 bool hasInput() { return qbRead.getSize() > 0; }
diff --git a/src/clientlink.h b/src/clientlink.h
index aa6d362..28910bb 100644
--- a/src/clientlink.h
+++ b/src/clientlink.h
@@ -8,7 +8,7 @@
 #ifndef BU_CLIENT_LINK_H
 #define BU_CLIENT_LINK_H
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 namespace Bu
 {
@@ -18,7 +18,7 @@ namespace Bu
                 ClientLink();
                 virtual ~ClientLink();
 
-                virtual void sendMessage( const Bu::FString &sMsg )=0;
+                virtual void sendMessage( const Bu::String &sMsg )=0;
         };
 };
 
diff --git a/src/compat/win32.h b/src/compat/win32.h
index 6304d4c..82ab4d6 100644
--- a/src/compat/win32.h
+++ b/src/compat/win32.h
@@ -18,7 +18,7 @@ extern "C"
 }
 #endif
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/singleton.h"
 
 #ifndef TEMP_FAILURE_RETRY
diff --git a/src/conduit.h b/src/conduit.h
index 7125fc5..f8ad4fa 100644
--- a/src/conduit.h
+++ b/src/conduit.h
@@ -9,7 +9,7 @@
 #define BU_CONDUIT_H
 
 #include "bu/stream.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 namespace Bu
 {
diff --git a/src/crypt.cpp b/src/crypt.cpp
index ae04353..97260c9 100644
--- a/src/crypt.cpp
+++ b/src/crypt.cpp
@@ -11,14 +11,14 @@
 #include "bu/membuf.h"
 #include "bu/file.h"
 
-Bu::FString Bu::cryptPass( const Bu::FString &sPass, const Bu::FString &sSalt )
+Bu::String Bu::cryptPass( const Bu::String &sPass, const Bu::String &sSalt )
 {
         Bu::Md5 md5;
         Bu::MemBuf mbOut;
         Bu::Base64 b64Out( mbOut );
         
-        Bu::FString::const_iterator i = sSalt.find('$');
-        Bu::FString sSaltSml = sSalt.getSubStr( sSalt.begin(), i );
+        Bu::String::const_iterator i = sSalt.find('$');
+        Bu::String sSaltSml = sSalt.getSubStr( sSalt.begin(), i );
 
         md5.addData( sPass );
         md5.addData( sSaltSml );
@@ -29,7 +29,7 @@ Bu::FString Bu::cryptPass( const Bu::FString &sPass, const Bu::FString &sSalt )
         return sSaltSml + "$" + mbOut.getString();
 }
 
-Bu::FString Bu::cryptPass( const Bu::FString &sPass )
+Bu::String Bu::cryptPass( const Bu::String &sPass )
 {
         Bu::MemBuf mbSalt;
         Bu::Base64 b64Salt( mbSalt );
diff --git a/src/crypt.h b/src/crypt.h
index cf7fb97..d6bfe4b 100644
--- a/src/crypt.h
+++ b/src/crypt.h
@@ -8,12 +8,12 @@
 #ifndef BU_CRYPT_H
 #define BU_CRYPT_H
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 namespace Bu
 {
-        FString cryptPass( const Bu::FString &sPass, const Bu::FString &sSalt );
-        FString cryptPass( const Bu::FString &sPass );
+        String cryptPass( const Bu::String &sPass, const Bu::String &sSalt );
+        String cryptPass( const Bu::String &sPass );
 };
 
 #endif
diff --git a/src/cryptohash.cpp b/src/cryptohash.cpp
index 8aee415..bb07a4b 100644
--- a/src/cryptohash.cpp
+++ b/src/cryptohash.cpp
@@ -15,15 +15,15 @@ Bu::CryptoHash::~CryptoHash()
 {
 }
 
-void Bu::CryptoHash::addData( const Bu::FString &sData )
+void Bu::CryptoHash::addData( const Bu::String &sData )
 {
         addData( sData.getStr(), sData.getSize() );
 }
 
-Bu::FString Bu::CryptoHash::getHexResult()
+Bu::String Bu::CryptoHash::getHexResult()
 {
-        Bu::FString sResult = getResult();
-        Bu::FString sRet( 2*sResult.getSize() );
+        Bu::String sResult = getResult();
+        Bu::String sRet( 2*sResult.getSize() );
         static const char hex_tab[] = {"0123456789abcdef"};
 
         int k = 0;
diff --git a/src/cryptohash.h b/src/cryptohash.h
index 5d83895..56dc356 100644
--- a/src/cryptohash.h
+++ b/src/cryptohash.h
@@ -8,7 +8,7 @@
 #ifndef BU_CRYPTO_HASH_H
 #define BU_CRYPTO_HASH_H
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 namespace Bu
 {
@@ -21,12 +21,12 @@ namespace Bu
                 virtual ~CryptoHash();
 
                 virtual void reset() = 0;
-                virtual void setSalt( const Bu::FString &sSalt ) = 0;
+                virtual void setSalt( const Bu::String &sSalt ) = 0;
                 virtual void addData( const void *sData, int iSize ) = 0;
-                virtual void addData( const Bu::FString &sData );
-                virtual FString getResult() = 0;
+                virtual void addData( const Bu::String &sData );
+                virtual String getResult() = 0;
                 virtual void writeResult( Stream &sOut ) = 0;
-                virtual Bu::FString getHexResult();
+                virtual Bu::String getHexResult();
         };
 };
 
diff --git a/src/csvreader.cpp b/src/csvreader.cpp
index f3133c2..22b0608 100644
--- a/src/csvreader.cpp
+++ b/src/csvreader.cpp
@@ -41,12 +41,12 @@ Bu::StrArray Bu::CsvReader::readLine()
 {
         Bu::StrArray aVals;
 
-        Bu::FString sLine = sIn.readLine();
+        Bu::String sLine = sIn.readLine();
 
         if( !sLine.isSet() )
                 return Bu::StrArray();
 
-        Bu::FString::iterator i = sLine.begin();
+        Bu::String::iterator i = sLine.begin();
 
         aVals.append( sDecode( i ) );
 
@@ -73,9 +73,9 @@ Bu::StrArray Bu::CsvReader::readLine()
         return aVals;
 }
 
-Bu::FString Bu::CsvReader::decodeExcel( Bu::FString::iterator &i )
+Bu::String Bu::CsvReader::decodeExcel( Bu::String::iterator &i )
 {
-        Bu::FString sRet;
+        Bu::String sRet;
 
         for(; i && (*i == ' ' || *i == '\t'); i++ ) { }
         
@@ -123,7 +123,7 @@ Bu::FString Bu::CsvReader::decodeExcel( Bu::FString::iterator &i )
         return sRet;
 }
 
-Bu::FString Bu::CsvReader::decodeC( Bu::FString::iterator & )
+Bu::String Bu::CsvReader::decodeC( Bu::String::iterator & )
 {
         return "";
 }
diff --git a/src/csvreader.h b/src/csvreader.h
index 9ad65fd..1c3525c 100644
--- a/src/csvreader.h
+++ b/src/csvreader.h
@@ -8,19 +8,19 @@
 #ifndef BU_CSV_READER_H
 #define BU_CSV_READER_H
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/array.h"
 #include "bu/signals.h"
 
 namespace Bu
 {
         class Stream;
-        typedef Bu::Array<Bu::FString> StrArray;
+        typedef Bu::Array<Bu::String> StrArray;
 
         class CsvReader
         {
         public:
-                typedef Bu::Signal1<Bu::FString, Bu::FString::iterator &> DecodeSignal;
+                typedef Bu::Signal1<Bu::String, Bu::String::iterator &> DecodeSignal;
                 enum Style
                 {
                         styleExcel, ///< Excel style quotes around things that need em
@@ -37,8 +37,8 @@ namespace Bu
                 Stream &sIn;
                 DecodeSignal sDecode;
 
-                static Bu::FString decodeExcel( Bu::FString::iterator &i );
-                static Bu::FString decodeC( Bu::FString::iterator &i );
+                static Bu::String decodeExcel( Bu::String::iterator &i );
+                static Bu::String decodeC( Bu::String::iterator &i );
         };
 };
 
diff --git a/src/csvwriter.cpp b/src/csvwriter.cpp
index 3e2816b..6b50ed0 100644
--- a/src/csvwriter.cpp
+++ b/src/csvwriter.cpp
@@ -36,7 +36,7 @@ Bu::CsvWriter::~CsvWriter()
 
 void Bu::CsvWriter::writeLine( const StrArray &aStrs )
 {
-        Bu::FString sBuf;
+        Bu::String sBuf;
         for( StrArray::const_iterator i = aStrs.begin(); i; i++ )
         {
                 if( i != aStrs.begin() )
@@ -48,12 +48,12 @@ void Bu::CsvWriter::writeLine( const StrArray &aStrs )
         sOut.write( sBuf );
 }
 
-Bu::FString Bu::CsvWriter::encodeExcel( const Bu::FString &sIn )
+Bu::String Bu::CsvWriter::encodeExcel( const Bu::String &sIn )
 {
         if( sIn.find('\"') )
         {
-                Bu::FString sOut = "\"";
-                for( Bu::FString::const_iterator i = sIn.begin(); i; i++ )
+                Bu::String sOut = "\"";
+                for( Bu::String::const_iterator i = sIn.begin(); i; i++ )
                 {
                         if( *i == '\"' )
                                 sOut += "\"\"";
@@ -65,10 +65,10 @@ Bu::FString Bu::CsvWriter::encodeExcel( const Bu::FString &sIn )
         return sIn;
 }
 
-Bu::FString Bu::CsvWriter::encodeC( const Bu::FString &sIn )
+Bu::String Bu::CsvWriter::encodeC( const Bu::String &sIn )
 {
-        Bu::FString sOut = "";
-        for( Bu::FString::const_iterator i = sIn.begin(); i; i++ )
+        Bu::String sOut = "";
+        for( Bu::String::const_iterator i = sIn.begin(); i; i++ )
         {
                 if( *i == ',' )
                         sOut += "\\,";
diff --git a/src/csvwriter.h b/src/csvwriter.h
index 289d25c..8da5eee 100644
--- a/src/csvwriter.h
+++ b/src/csvwriter.h
@@ -8,19 +8,19 @@
 #ifndef BU_CSV_WRITER_H
 #define BU_CSV_WRITER_H
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/array.h"
 #include "bu/signals.h"
 
 namespace Bu
 {
         class Stream;
-        typedef Bu::Array<Bu::FString> StrArray;
+        typedef Bu::Array<Bu::String> StrArray;
 
         class CsvWriter
         {
         public:
-                typedef Bu::Signal1<Bu::FString, const Bu::FString &> EncodeSignal;
+                typedef Bu::Signal1<Bu::String, const Bu::String &> EncodeSignal;
                 enum Style
                 {
                         styleExcel, ///< Excel style quotes around things that need em
@@ -37,8 +37,8 @@ namespace Bu
                 Stream &sOut;
                 EncodeSignal sEncode;
 
-                static Bu::FString encodeExcel( const Bu::FString &sIn );
-                static Bu::FString encodeC( const Bu::FString &sIn );
+                static Bu::String encodeExcel( const Bu::String &sIn );
+                static Bu::String encodeC( const Bu::String &sIn );
         };
 };
 
diff --git a/src/fastcgi.cpp b/src/fastcgi.cpp
index ca3010e..1b012e8 100644
--- a/src/fastcgi.cpp
+++ b/src/fastcgi.cpp
@@ -114,14 +114,14 @@ void Bu::FastCgi::readPair( Bu::TcpSocket &s, StrHash &hParams, uint16_t &uRead
         uRead += uName + uValue;
         unsigned char *sName = new unsigned char[uName];
         s.read( sName, uName );
-        Bu::FString fsName( (char *)sName, uName );
+        Bu::String fsName( (char *)sName, uName );
         delete[] sName;
 
         if( uValue > 0 )
         {
                 unsigned char *sValue = new unsigned char[uValue];
                 s.read( sValue, uValue );
-                Bu::FString fsValue( (char *)sValue, uValue );
+                Bu::String fsValue( (char *)sValue, uValue );
                 hParams.insert( fsName, fsValue );
                 delete[] sValue;
         }
@@ -305,8 +305,8 @@ void Bu::FastCgi::run()
                                                         mStdOut, mStdErr
                                                         );
 
-                                                Bu::FString &sStdOut = mStdOut.getString();
-                                                Bu::FString &sStdErr = mStdErr.getString();
+                                                Bu::String &sStdOut = mStdOut.getString();
+                                                Bu::String &sStdErr = mStdErr.getString();
 
                                                 Record rOut;
                                                 memset( &rOut, 0, sizeof(rOut) );
diff --git a/src/fastcgi.h b/src/fastcgi.h
index 7c1c04c..4463bee 100644
--- a/src/fastcgi.h
+++ b/src/fastcgi.h
@@ -8,7 +8,7 @@
 #ifndef BU_FAST_CGI_H
 #define BU_FAST_CGI_H
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/hash.h"
 #include "bu/array.h"
 #include "bu/tcpsocket.h"
@@ -27,7 +27,7 @@ namespace Bu
 
                 static bool isEmbedded();
 
-                typedef Bu::Hash<Bu::FString, Bu::FString> StrHash;
+                typedef Bu::Hash<Bu::String, Bu::String> StrHash;
                 enum RequestType
                 {
                         typeBeginRequest        = 1,
@@ -86,8 +86,8 @@ namespace Bu
                 typedef struct Channel {
                         Channel() : uFlags( 0 ) { }
                         StrHash hParams;
-                        Bu::FString sStdIn;
-                        Bu::FString sData;
+                        Bu::String sStdIn;
+                        Bu::String sData;
                         uint8_t uFlags;
                 } Channel;
 
@@ -104,7 +104,7 @@ namespace Bu
 
                 virtual void onInit() { };
                 virtual int onRequest( const StrHash &hParams,
-                        const Bu::FString &sStdIn, Bu::Stream &sStdOut,
+                        const Bu::String &sStdIn, Bu::Stream &sStdOut,
                         Bu::Stream &sStdErr )=0;
                 virtual void onUninit() { };
 
diff --git a/src/fbasicstring.cpp b/src/fbasicstring.cpp
deleted file mode 100644
index 4834301..0000000
--- a/src/fbasicstring.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-/*
- * Copyright (C) 2007-2010 Xagasoft, All rights reserved.
- *
- * This file is part of the libbu++ library and is released under the
- * terms of the license contained in the file LICENSE.
- */
-
-#include "bu/fbasicstring.h"
-
diff --git a/src/fifo.cpp b/src/fifo.cpp
index d1fa960..d6106cc 100644
--- a/src/fifo.cpp
+++ b/src/fifo.cpp
@@ -16,7 +16,7 @@
 
 namespace Bu { subExceptionDef( FifoException ) }
 
-Bu::Fifo::Fifo( const Bu::FString &sName, int iFlags, mode_t mAcc ) :
+Bu::Fifo::Fifo( const Bu::String &sName, int iFlags, mode_t mAcc ) :
         iFlags( iFlags ),
         iIn( -1 ),
         iOut( -1 )
diff --git a/src/fifo.h b/src/fifo.h
index fc70b2c..140e966 100644
--- a/src/fifo.h
+++ b/src/fifo.h
@@ -13,7 +13,7 @@
 #include <stdlib.h>
 
 #include "bu/stream.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/exceptionbase.h"
 
 namespace Bu
@@ -27,7 +27,7 @@ namespace Bu
         class Fifo : public Bu::Stream
         {
         public:
-                Fifo( const Bu::FString &sName, int iFlags, mode_t mAcc=-1 );
+                Fifo( const Bu::String &sName, int iFlags, mode_t mAcc=-1 );
                 virtual ~Fifo();
 
                 virtual void close();
diff --git a/src/file.cpp b/src/file.cpp
index 008b88e..6634a62 100644
--- a/src/file.cpp
+++ b/src/file.cpp
@@ -17,7 +17,7 @@
 
 namespace Bu { subExceptionDef( FileException ) }
 
-Bu::File::File( const Bu::FString &sName, int iFlags ) :
+Bu::File::File( const Bu::String &sName, int iFlags ) :
         fd( -1 ),
         bEos( true )
 {
@@ -187,7 +187,7 @@ void Bu::File::setBlocking( bool bBlocking )
 #endif
 }
 
-Bu::File Bu::File::tempFile( Bu::FString &sName )
+Bu::File Bu::File::tempFile( Bu::String &sName )
 {
         uint32_t iX;
         iX = time( NULL ) + getpid();
diff --git a/src/file.h b/src/file.h
index b2cd2a4..81c1592 100644
--- a/src/file.h
+++ b/src/file.h
@@ -12,7 +12,7 @@
 #include <sys/types.h>
 
 #include "bu/stream.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/exceptionbase.h"
 
 namespace Bu
@@ -26,7 +26,7 @@ namespace Bu
         class File : public Bu::Stream
         {
         public:
-                File( const Bu::FString &sName, int iFlags );
+                File( const Bu::String &sName, int iFlags );
                 File( int fd );
                 virtual ~File();
 
@@ -75,12 +75,12 @@ namespace Bu
                 /**
                  * Create a temp file and return its handle.  The file is opened 
                  * Read/Write.
-                 *@param sName (Bu::FString) Give in the form: "/tmp/tmpfileXXXXXXXX"
+                 *@param sName (Bu::String) Give in the form: "/tmp/tmpfileXXXXXXXX"
                  *              It will alter your (sName) setting the 'X's to random
                  *              characters.
                  *@returns (Bu::File) A file object representing your temp file.
                  */
-                static Bu::File tempFile( Bu::FString &sName );
+                static Bu::File tempFile( Bu::String &sName );
 
 #ifndef WIN32
                 /**
diff --git a/src/formatter.cpp b/src/formatter.cpp
index 7eaa1e2..9288e91 100644
--- a/src/formatter.cpp
+++ b/src/formatter.cpp
@@ -21,7 +21,7 @@ Bu::Formatter::~Formatter()
 {
 }
 
-void Bu::Formatter::write( const Bu::FString &sStr )
+void Bu::Formatter::write( const Bu::String &sStr )
 {
         rStream.write( sStr );
 }
@@ -31,7 +31,7 @@ void Bu::Formatter::write( const void *sStr, int iLen )
         rStream.write( sStr, iLen );
 }
 
-void Bu::Formatter::writeAligned( const Bu::FString &sStr )
+void Bu::Formatter::writeAligned( const Bu::String &sStr )
 {
         int iLen = sStr.getSize();
         if( iLen > fLast.uMinWidth )
@@ -117,9 +117,9 @@ void Bu::Formatter::read( void *sStr, int iLen )
         rStream.read( sStr, iLen );
 }
 
-Bu::FString Bu::Formatter::readToken()
+Bu::String Bu::Formatter::readToken()
 {
-        Bu::FString sRet;
+        Bu::String sRet;
         if( fLast.bTokenize )
         {
                 for(;;)
@@ -292,7 +292,7 @@ Bu::Formatter &Bu::operator<<( Bu::Formatter &f, char *sStr )
         return f;
 }
 
-Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::FString &sStr )
+Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::String &sStr )
 {
         f.writeAligned( sStr );
         return f;
@@ -388,7 +388,7 @@ Bu::Formatter &Bu::operator<<( Bu::Formatter &f, bool b )
         return f;
 }
 
-Bu::Formatter &Bu::operator>>( Bu::Formatter &f, Bu::FString &sStr )
+Bu::Formatter &Bu::operator>>( Bu::Formatter &f, Bu::String &sStr )
 {
         sStr = f.readToken();
         return f;
@@ -480,7 +480,7 @@ Bu::Formatter &Bu::operator>>( Bu::Formatter &f, long double &flt )
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, bool &b )
 {
-        Bu::FString sStr = f.readToken();
+        Bu::String sStr = f.readToken();
         if( !sStr.isSet() )
                 return f;
         char c = *sStr.begin();
diff --git a/src/formatter.h b/src/formatter.h
index 7e0c54b..fb51c81 100644
--- a/src/formatter.h
+++ b/src/formatter.h
@@ -103,13 +103,13 @@ namespace Bu
                         unsigned short bTokenize : 1;
                 } Fmt;
 
-                void write( const Bu::FString &sStr );
+                void write( const Bu::String &sStr );
                 void write( const void *sStr, int iLen );
-                void writeAligned( const Bu::FString &sStr );
+                void writeAligned( const Bu::String &sStr );
                 void writeAligned( const char *sStr, int iLen );
 
                 void read( void *sStr, int iLen );
-                Bu::FString readToken();
+                Bu::String readToken();
 
                 void incIndent();
                 void decIndent();
@@ -199,7 +199,7 @@ namespace Bu
                 template<typename type>
                 void ffmt( type f )
                 {
-                        Bu::FString fTmp;
+                        Bu::String fTmp;
                         fTmp.format("%f", f );
 //                      writeAligned("**make floats work**");
                         writeAligned( fTmp );
@@ -207,7 +207,7 @@ namespace Bu
                 }
                 
                 template<typename type>
-                void iparse( type &i, const Bu::FString &sBuf )
+                void iparse( type &i, const Bu::String &sBuf )
                 {
                         if( !sBuf.isSet() )
                                 return;
@@ -233,7 +233,7 @@ namespace Bu
                 }
                 
                 template<typename type>
-                void uparse( type &i, const Bu::FString &sBuf )
+                void uparse( type &i, const Bu::String &sBuf )
                 {
                         if( !sBuf.isSet() )
                                 return;
@@ -257,7 +257,7 @@ namespace Bu
                 }
                 
                 template<typename type>
-                void fparse( type &f, const Bu::FString &sBuf )
+                void fparse( type &f, const Bu::String &sBuf )
                 {
                         sscanf( sBuf.getStr(), "%f", &f );
                         usedFormat();
@@ -288,7 +288,7 @@ namespace Bu
         Formatter &operator<<( Formatter &f, Formatter::Special s );
         Formatter &operator<<( Formatter &f, const char *sStr );
         Formatter &operator<<( Formatter &f, char *sStr );
-        Formatter &operator<<( Formatter &f, const Bu::FString &sStr );
+        Formatter &operator<<( Formatter &f, const Bu::String &sStr );
         Formatter &operator<<( Formatter &f, signed char c );
         Formatter &operator<<( Formatter &f, char c );
         Formatter &operator<<( Formatter &f, unsigned char c );
@@ -305,7 +305,7 @@ namespace Bu
         Formatter &operator<<( Formatter &f, long double flt );
         Formatter &operator<<( Formatter &f, bool b );
 
-        Formatter &operator>>( Formatter &f, Bu::FString &sStr );
+        Formatter &operator>>( Formatter &f, Bu::String &sStr );
         Formatter &operator>>( Formatter &f, signed char &c );
         Formatter &operator>>( Formatter &f, char &c );
         Formatter &operator>>( Formatter &f, unsigned char &c );
diff --git a/src/formula.h b/src/formula.h
index d93e27b..757884f 100644
--- a/src/formula.h
+++ b/src/formula.h
@@ -17,7 +17,7 @@
 #include "bu/stack.h"
 #include "bu/exceptionbase.h"
 #include "bu/hash.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 namespace Bu
 {
@@ -41,8 +41,8 @@ namespace Bu
                         virtual prec operator()( prec )=0;
                 };
 
-                typedef Hash<Bu::FString, prec> varHash;
-                typedef Hash<Bu::FString, Func *> funcHash;
+                typedef Hash<Bu::String, prec> varHash;
+                typedef Hash<Bu::String, Func *> funcHash;
 
                 Formula()
                 {
@@ -57,7 +57,7 @@ namespace Bu
                         }
                 }
 
-                prec run( const Bu::FString &sFormulaSrc )
+                prec run( const Bu::String &sFormulaSrc )
                 {
                         if( sFormulaSrc.isEmpty() )
                                 throw FormulaException("Empty formula, nothing to do.");
@@ -158,7 +158,7 @@ namespace Bu
 
                 Bu::Stack<symType> sOper;
                 Bu::Stack<prec> sValue;
-                Bu::Stack<Bu::FString> sFunc;
+                Bu::Stack<Bu::String> sFunc;
 
         private:
                 symType getPrec( symType nOper )
diff --git a/src/fstring.h b/src/fstring.h
deleted file mode 100644
index 0f9d81a..0000000
--- a/src/fstring.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (C) 2007-2010 Xagasoft, All rights reserved.
- *
- * This file is part of the libbu++ library and is released under the
- * terms of the license contained in the file LICENSE.
- */
-
-#ifndef BU_F_STRING_H
-#define BU_F_STRING_H
-
-#include "bu/fbasicstring.h"
-
-namespace Bu
-{
-        typedef FBasicString<char> FString;
-
-        template<typename T>
-        uint32_t __calcHashCode( const T &k );
-
-        template<typename T>
-        bool __cmpHashKeys( const T &a, const T &b );
-
-        template<> uint32_t __calcHashCode<FString>( const FString &k );
-        template<> bool __cmpHashKeys<FString>(
-                const FString &a, const FString &b );
-        
-        template<typename t> void __tracer_format( const t &v );
-        template<> void __tracer_format<FString>( const FString &v );
-
-        bool &operator<<( bool &dst, const FString &sIn );
-        uint8_t &operator<<( uint8_t &dst, const FString &sIn );
-        int8_t &operator<<( int8_t &dst, const FString &sIn );
-        char &operator<<( char &dst, const FString &sIn );
-        uint16_t &operator<<( uint16_t &dst, const FString &sIn );
-        int16_t &operator<<( int16_t &dst, const FString &sIn );
-        uint32_t &operator<<( uint32_t &dst, const FString &sIn );
-        int32_t &operator<<( int32_t &dst, const FString &sIn );
-        uint64_t &operator<<( uint64_t &dst, const FString &sIn );
-        int64_t &operator<<( int64_t &dst, const FString &sIn );
-        float &operator<<( float &dst, const FString &sIn );
-        double &operator<<( double &dst, const FString &sIn );
-        long double &operator<<( long double &dst, const FString &sIn );
-        Bu::FString &operator<<( Bu::FString &dst, const FString &sIn );
-
-}
-
-/***** I dunno about this block, I don't really want to have it... *****
-#include <ostream>
-std::basic_ostream<char>& operator<< (std::basic_ostream<char> &os,
-        const Bu::FString &val );
-*/
-
-#endif
diff --git a/src/hash.h b/src/hash.h
index 354569e..04c3e76 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -411,7 +411,7 @@ namespace Bu
          * In order to use it, I recommend the following for all basic usage:
          *@code
          // Define a Hash typedef with strings as keys and ints as values.
-         typedef Bu::Hash<Bu::FString, int> StrIntHash;
+         typedef Bu::Hash<Bu::String, int> StrIntHash;
 
          // Create one
          StrIntHash hInts;
diff --git a/src/httpget.cpp b/src/httpget.cpp
index 2347167..673cdd6 100644
--- a/src/httpget.cpp
+++ b/src/httpget.cpp
@@ -7,7 +7,7 @@
 
 #include "bu/httpget.h"
 
-Bu::HttpGet::HttpGet( const Bu::Url &uSrc, const Bu::FString &sMethod ) :
+Bu::HttpGet::HttpGet( const Bu::Url &uSrc, const Bu::String &sMethod ) :
         uSrc( uSrc ),
         sMethod( sMethod ),
         sSrv( uSrc.getHost(), uSrc.getPort() )
diff --git a/src/httpget.h b/src/httpget.h
index 783f880..58982c0 100644
--- a/src/httpget.h
+++ b/src/httpget.h
@@ -9,7 +9,7 @@
 #define BU_HTTP_GET_H
 
 #include "bu/stream.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/url.h"
 #include "bu/tcpsocket.h"
 #include "bu/hash.h"
@@ -19,7 +19,7 @@ namespace Bu
         class HttpGet : public Bu::Stream
         {
         public:
-                HttpGet( const Bu::Url &uSrc, const Bu::FString &sMethod="GET" );
+                HttpGet( const Bu::Url &uSrc, const Bu::String &sMethod="GET" );
                 virtual ~HttpGet();
 
                 void get();
@@ -51,9 +51,9 @@ namespace Bu
 
         private:
                 Bu::Url uSrc;
-                Bu::FString sMethod;
+                Bu::String sMethod;
                 Bu::TcpSocket sSrv;
-                typedef Bu::Hash<Bu::FString,Bu::FString> MimeHash;
+                typedef Bu::Hash<Bu::String,Bu::String> MimeHash;
                 MimeHash hMimeIn;
                 MimeHash hMimeOut;
         };
diff --git a/src/itoserver.cpp b/src/itoserver.cpp
index ea737bf..80e5bfb 100644
--- a/src/itoserver.cpp
+++ b/src/itoserver.cpp
@@ -47,7 +47,7 @@ void Bu::ItoServer::addPort( int nPort, int nPoolSize )
         hServers.insert( nSocket, s );
 }
 
-void Bu::ItoServer::addPort( const FString &sAddr, int nPort, int nPoolSize )
+void Bu::ItoServer::addPort( const String &sAddr, int nPort, int nPoolSize )
 {
         TcpServerSocket *s = new TcpServerSocket( sAddr, nPort, nPoolSize );
         int nSocket = s->getSocket();
@@ -163,7 +163,7 @@ void Bu::ItoServer::ItoClient::run()
                 while( !qMsg.isEmpty() )
                 {
                         imProto.lock();
-                        Bu::FString *pMsg = qMsg.dequeue();
+                        Bu::String *pMsg = qMsg.dequeue();
                         pClient->onMessage( *pMsg );
                         delete pMsg;
                         pClient->processOutput();
@@ -205,7 +205,7 @@ Bu::ItoServer::SrvClientLink::~SrvClientLink()
 {
 }
 
-void Bu::ItoServer::SrvClientLink::sendMessage( const Bu::FString &sMsg )
+void Bu::ItoServer::SrvClientLink::sendMessage( const Bu::String &sMsg )
 {
         if( !pClient->imProto.trylock() )
         {
@@ -215,7 +215,7 @@ void Bu::ItoServer::SrvClientLink::sendMessage( const Bu::FString &sMsg )
         }
         else
         {
-                Bu::FString *pMsg = new Bu::FString( sMsg );
+                Bu::String *pMsg = new Bu::String( sMsg );
                 pClient->qMsg.enqueue( pMsg );
         }
 }
diff --git a/src/itoserver.h b/src/itoserver.h
index 81e42cc..83e7552 100644
--- a/src/itoserver.h
+++ b/src/itoserver.h
@@ -14,7 +14,7 @@
         #include <sys/select.h>
 #endif
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/list.h"
 #include "bu/ito.h"
 #include "bu/itomutex.h"
@@ -59,7 +59,7 @@ namespace Bu
                 virtual ~ItoServer();
 
                 void addPort( int nPort, int nPoolSize=40 );
-                void addPort( const FString &sAddr, int nPort, int nPoolSize=40 );
+                void addPort( const String &sAddr, int nPort, int nPoolSize=40 );
 
                 //void scan();
                 void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 );
@@ -82,7 +82,7 @@ namespace Bu
                                         int nTimeoutSec, int nTimeoutUSec );
                         virtual ~ItoClient();
 
-                        typedef ItoQueue<Bu::FString *> StringQueue;
+                        typedef ItoQueue<Bu::String *> StringQueue;
                         StringQueue qMsg;
 
                 protected:
@@ -105,7 +105,7 @@ namespace Bu
                         SrvClientLink( ItoClient *pClient );
                         virtual ~SrvClientLink();
 
-                        virtual void sendMessage( const Bu::FString &sMsg );
+                        virtual void sendMessage( const Bu::String &sMsg );
 
                 private:
                         ItoClient *pClient;
diff --git a/src/lexer.cpp b/src/lexer.cpp
index af9a23f..5db6bbc 100644
--- a/src/lexer.cpp
+++ b/src/lexer.cpp
@@ -18,7 +18,7 @@ Bu::Lexer::Token::Token( Bu::Lexer::TokenType iToken ) :
 {
 }
 
-Bu::FString Bu::Lexer::tokenToString( const Bu::Lexer::Token &t )
+Bu::String Bu::Lexer::tokenToString( const Bu::Lexer::Token &t )
 {
         Bu::MemBuf mb;
         Bu::Formatter f( mb );
diff --git a/src/lexer.h b/src/lexer.h
index 9840afe..f4e0479 100644
--- a/src/lexer.h
+++ b/src/lexer.h
@@ -44,7 +44,7 @@ namespace Bu
 
                 virtual Token *nextToken()=0;
 
-                virtual Bu::FString tokenToString( const Token &t );
+                virtual Bu::String tokenToString( const Token &t );
         };
 };
 
diff --git a/src/logger.cpp b/src/logger.cpp
index 9f734a9..eb5ac2d 100644
--- a/src/logger.cpp
+++ b/src/logger.cpp
@@ -69,7 +69,7 @@ void Bu::Logger::log( uint32_t nLevel, const char *sFile, const char *sFunction,
 #endif
 }
 
-void Bu::Logger::setFormat( const Bu::FString &str )
+void Bu::Logger::setFormat( const Bu::String &str )
 {
         sLogFormat = "";
 
@@ -93,7 +93,7 @@ void Bu::Logger::setFormat( const Bu::FString &str )
                 if( *s == '%' )
                 {
                         sLogFormat += '%';
-                        Bu::FString sBuf;
+                        Bu::String sBuf;
                         for(;;)
                         {
                                 s++;
@@ -166,10 +166,10 @@ void Bu::Logger::hexDump( uint32_t nLevel, const char *sFile,
         log( nLevel, sFile, sFunction, nLine, "Displaying %ld bytes of %s.", nDataLen, lpName );
         const unsigned char *pData = (const unsigned char *)pDataV;
         int j = 0;
-        Bu::FString sBorder;
+        Bu::String sBorder;
         for( int l = 0; l < 8*3+2*8+2+5; l++ ) sBorder += ((l!=11&&l!=37)?("-"):("+"));
         log( nLevel, sFile, sFunction, nLine, sBorder.getStr() );
-        Bu::FString sLine;
+        Bu::String sLine;
         for(;;)
         {
                 {
diff --git a/src/logger.h b/src/logger.h
index 6a7a2d5..9a4b030 100644
--- a/src/logger.h
+++ b/src/logger.h
@@ -9,7 +9,7 @@
 #define BU_LOGGER_H
 
 #include "bu/singleton.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 namespace Bu
 {
@@ -78,7 +78,7 @@ namespace Bu
         public:
                 void log( uint32_t nLevel, const char *sFile, const char *sFunction, int nLine, const char *sFormat, ...);
 
-                void setFormat( const Bu::FString &str );
+                void setFormat( const Bu::String &str );
                 void setMask( uint32_t n );
                 void setLevel( uint32_t n );
                 uint32_t getMask();
@@ -86,7 +86,7 @@ namespace Bu
                 void hexDump( uint32_t nLevel, const char *sFile, const char *sFunction, int nLine, const void *pData, long nDataLen, const char *lpName );
 
         private:
-                Bu::FString sLogFormat;
+                Bu::String sLogFormat;
                 uint32_t nLevelMask;
         };
 }
diff --git a/src/md5.cpp b/src/md5.cpp
index abf4bfa..db70ddc 100644
--- a/src/md5.cpp
+++ b/src/md5.cpp
@@ -60,7 +60,7 @@ void Bu::Md5::reset()
         iFill = 0;
 }
 
-void Bu::Md5::setSalt( const Bu::FString & /*sSalt*/ )
+void Bu::Md5::setSalt( const Bu::String & /*sSalt*/ )
 {
 }
 
@@ -84,11 +84,11 @@ void Bu::Md5::addData( const void *sVData, int iSize )
         iBytes += iSize;
 }
 
-Bu::FString Bu::Md5::getResult()
+Bu::String Bu::Md5::getResult()
 {
         long lsum[4];
         compCap( lsum );
-        return Bu::FString( (const char *)lsum, 4*4 );
+        return Bu::String( (const char *)lsum, 4*4 );
 }
 
 void Bu::Md5::writeResult( Bu::Stream &sOut )
diff --git a/src/md5.h b/src/md5.h
index 79b1d09..d43574d 100644
--- a/src/md5.h
+++ b/src/md5.h
@@ -26,10 +26,10 @@ namespace Bu
                 virtual ~Md5();
 
                 virtual void reset();
-                virtual void setSalt( const Bu::FString &sSalt );
+                virtual void setSalt( const Bu::String &sSalt );
                 virtual void addData( const void *sData, int iSize );
                 using Bu::CryptoHash::addData;
-                virtual FString getResult();
+                virtual String getResult();
                 virtual void writeResult( Bu::Stream &sOut );
 
         private:
diff --git a/src/membuf.cpp b/src/membuf.cpp
index 1a6bf9a..2dc266f 100644
--- a/src/membuf.cpp
+++ b/src/membuf.cpp
@@ -14,7 +14,7 @@ Bu::MemBuf::MemBuf() :
 {
 }
 
-Bu::MemBuf::MemBuf( const Bu::FString &str ) :
+Bu::MemBuf::MemBuf( const Bu::String &str ) :
         sBuf( str ),
         nPos( 0 )
 {
@@ -149,12 +149,12 @@ void Bu::MemBuf::setSize( size iSize )
                 nPos = iSize;
 }
 
-Bu::FString &Bu::MemBuf::getString()
+Bu::String &Bu::MemBuf::getString()
 {
         return sBuf;
 }
 
-void Bu::MemBuf::setString( const Bu::FString &sNewData )
+void Bu::MemBuf::setString( const Bu::String &sNewData )
 {
         sBuf = sNewData;
         nPos = 0;
diff --git a/src/membuf.h b/src/membuf.h
index a75aca1..7faa956 100644
--- a/src/membuf.h
+++ b/src/membuf.h
@@ -12,7 +12,7 @@
 
 #include "bu/config.h"
 #include "bu/stream.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 namespace Bu
 {
@@ -24,7 +24,7 @@ namespace Bu
         {
         public:
                 MemBuf();
-                MemBuf( const Bu::FString &str );
+                MemBuf( const Bu::String &str );
                 virtual ~MemBuf();
 
                 virtual void close();
@@ -48,11 +48,11 @@ namespace Bu
                 virtual void setBlocking( bool bBlocking=true );
                 virtual void setSize( size iSize );
 
-                Bu::FString &getString();
-                void setString( const Bu::FString &sNewData );
+                Bu::String &getString();
+                void setString( const Bu::String &sNewData );
 
         private:
-                Bu::FString sBuf;
+                Bu::String sBuf;
                 size nPos;
         };
 }
diff --git a/src/minicron.cpp b/src/minicron.cpp
index 491d143..307880e 100644
--- a/src/minicron.cpp
+++ b/src/minicron.cpp
@@ -73,7 +73,7 @@ void Bu::MiniCron::poll()
         }
 }
 
-Bu::MiniCron::JobId Bu::MiniCron::addJob( const Bu::FString &sName,
+Bu::MiniCron::JobId Bu::MiniCron::addJob( const Bu::String &sName,
                 Bu::MiniCron::CronSignal sigJob, const Bu::MiniCron::Timer &t )
 {
         JobId jid = jidNext++;
@@ -86,7 +86,7 @@ Bu::MiniCron::JobId Bu::MiniCron::addJob( const Bu::FString &sName,
         return jid;
 }
 
-Bu::MiniCron::JobId Bu::MiniCron::addJobOnce( const Bu::FString &sName,
+Bu::MiniCron::JobId Bu::MiniCron::addJobOnce( const Bu::String &sName,
                 Bu::MiniCron::CronSignal sigJob, const Bu::MiniCron::Timer &t )
 {
         JobId jid = jidNext++;
@@ -132,7 +132,7 @@ Bu::MiniCron::JobInfoList Bu::MiniCron::getJobInfo()
         return lRet;
 }
 
-Bu::MiniCron::Job::Job( const Bu::FString &sName, JobId jid, bool bRepeat ) :
+Bu::MiniCron::Job::Job( const Bu::String &sName, JobId jid, bool bRepeat ) :
         sName( sName ),
         pTimer( NULL ),
         bContinue( bRepeat ),
@@ -202,12 +202,12 @@ time_t Bu::MiniCron::Job::getNextRunTime() const
         return tNextRun;
 }
 
-Bu::FString Bu::MiniCron::Job::getName() const
+Bu::String Bu::MiniCron::Job::getName() const
 {
         return sName;
 }
 
-Bu::MiniCron::JobInfo::JobInfo( const Bu::FString &sName, JobId jid,
+Bu::MiniCron::JobInfo::JobInfo( const Bu::String &sName, JobId jid,
                 time_t tNext ) :
         sName( sName ),
         jid( jid ),
@@ -249,7 +249,7 @@ time_t Bu::MiniCron::TimerInterval::nextTime()
         return tRet;
 }
 
-Bu::MiniCron::TimerBasic::TimerBasic( const Bu::FString &s ) :
+Bu::MiniCron::TimerBasic::TimerBasic( const Bu::String &s ) :
         tLast( -1 ),
         sSpec( s )
 {
@@ -264,7 +264,7 @@ time_t Bu::MiniCron::TimerBasic::nextTime()
         if( tLast == -1 )
                 tLast = time( NULL );
 
-        Bu::FString::const_iterator i = sSpec.begin();
+        Bu::String::const_iterator i = sSpec.begin();
         switch( lex( i ) )
         {
                 case tokDaily:
@@ -343,19 +343,19 @@ time_t Bu::MiniCron::TimerBasic::nextTime()
 }
 
 Bu::MiniCron::TimerBasic::Token Bu::MiniCron::TimerBasic::lex(
-                Bu::FString::const_iterator &i )
+                Bu::String::const_iterator &i )
 {
         if( !i )
         {
                 return tokEos;
         }
 
-        Bu::FString::const_iterator b = i;
+        Bu::String::const_iterator b = i;
 
         for(; b && (*b == ' ' || *b == '\t'); b++ ) { i = b+1; }
         for(; b && *b != ' ' && *b != '\t'; b++ ) { }
 
-        Bu::FString sTok( i, b );
+        Bu::String sTok( i, b );
         i = b;
 
         if( sTok == "daily" )
@@ -412,7 +412,7 @@ Bu::MiniCron::TimerBasic::Token Bu::MiniCron::TimerBasic::lex(
         return tokErr;
 }
 
-int Bu::MiniCron::TimerBasic::lexInt( Bu::FString::const_iterator &i )
+int Bu::MiniCron::TimerBasic::lexInt( Bu::String::const_iterator &i )
 {
         Token t = lex( i );
         if( t == tokEos )
diff --git a/src/minicron.h b/src/minicron.h
index b045e79..42369f5 100644
--- a/src/minicron.h
+++ b/src/minicron.h
@@ -10,7 +10,7 @@
 
 #include "bu/signals.h"
 #include "bu/heap.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 #include <time.h>
 
@@ -89,7 +89,7 @@ namespace Bu
                  * JobId which can be used at a later time to control the execution of
                  * the job.
                  */
-                virtual JobId addJob( const Bu::FString &sName, CronSignal sigJob,
+                virtual JobId addJob( const Bu::String &sName, CronSignal sigJob,
                                 const Timer &t );
 
                 /**
@@ -98,7 +98,7 @@ namespace Bu
                  * function returns a JobId which can be used at a later time to control
                  * the execution of the job.
                  */
-                virtual JobId addJobOnce( const Bu::FString &sName, CronSignal sigJob,
+                virtual JobId addJobOnce( const Bu::String &sName, CronSignal sigJob,
                                 const Timer &t );
 
                 /**
@@ -113,12 +113,12 @@ namespace Bu
                 class JobInfo
                 {
                 public:
-                        JobInfo( const Bu::FString &sName, JobId jid, time_t tNext );
+                        JobInfo( const Bu::String &sName, JobId jid, time_t tNext );
                         virtual ~JobInfo();
                         
                         bool operator<( const JobInfo &rhs ) const;
 
-                        Bu::FString sName;
+                        Bu::String sName;
                         JobId jid;
                         time_t tNext;
                 };
@@ -189,7 +189,7 @@ namespace Bu
                 class TimerBasic : public Timer
                 {
                 public:
-                        TimerBasic( const Bu::FString &s );
+                        TimerBasic( const Bu::String &s );
                         virtual ~TimerBasic();
 
                         virtual time_t nextTime();
@@ -208,11 +208,11 @@ namespace Bu
                                 tokErr,
                                 tokEos
                         };
-                        Token lex( Bu::FString::const_iterator &i );
-                        int lexInt( Bu::FString::const_iterator &i );
+                        Token lex( Bu::String::const_iterator &i );
+                        int lexInt( Bu::String::const_iterator &i );
                         int iVal; //< A temp variable for parsing.
                         time_t tLast;
-                        Bu::FString sSpec;
+                        Bu::String sSpec;
                 };
                 
                 /**
@@ -225,7 +225,7 @@ namespace Bu
                 {
                         friend class Bu::MiniCron;
                 private:
-                        Job( const Bu::FString &sName, JobId jid, bool bRepeat=true );
+                        Job( const Bu::String &sName, JobId jid, bool bRepeat=true );
                         virtual ~Job();
 
                 public:
@@ -290,10 +290,10 @@ namespace Bu
                         /**
                          * Gets the name that was set when the job was created.
                          */
-                        Bu::FString getName() const;
+                        Bu::String getName() const;
 
                 private:
-                        Bu::FString sName;
+                        Bu::String sName;
                         CronSignal sigJob;
                         time_t tNextRun;
                         Timer *pTimer;
diff --git a/src/minimacro.cpp b/src/minimacro.cpp
index df1a5c9..6c5a7c9 100644
--- a/src/minimacro.cpp
+++ b/src/minimacro.cpp
@@ -25,10 +25,10 @@ Bu::MiniMacro::~MiniMacro()
 {
 }
 
-Bu::FString Bu::MiniMacro::parse( const Bu::FString &sIn )
+Bu::String Bu::MiniMacro::parse( const Bu::String &sIn )
 {
         bContinue = true;
-        Bu::FString sOut;
+        Bu::String sOut;
         for( sCur = sIn.getStr(); *sCur && bContinue; sCur++ )
         {
                 if( *sCur == '{' )
@@ -66,16 +66,16 @@ Bu::FString Bu::MiniMacro::parse( const Bu::FString &sIn )
         return sOut;
 }
 
-Bu::FString Bu::MiniMacro::parseRepl()
+Bu::String Bu::MiniMacro::parseRepl()
 {
-        Bu::FString sOut;
+        Bu::String sOut;
         bool bIsFirst = true;
         for( const char *sNext = sCur;;)
         {
                 for(; *sNext != ':' && *sNext != '}' && *sNext != '\0'; sNext++ ) { }
                 if( *sNext == '\0' )
                         break;
-                Bu::FString sName( sCur, (ptrdiff_t)sNext-(ptrdiff_t)sCur );
+                Bu::String sName( sCur, (ptrdiff_t)sNext-(ptrdiff_t)sCur );
                 if( bIsFirst )
                 {
                         sOut = hVars[sName];
@@ -101,21 +101,21 @@ Bu::FString Bu::MiniMacro::parseRepl()
         return sOut;
 }
 
-Bu::FString Bu::MiniMacro::parseCond()
+Bu::String Bu::MiniMacro::parseCond()
 {
-        Bu::FString sOut;
+        Bu::String sOut;
         //printf("%20s\n", sCur );
         return sOut;
 }
 
-Bu::FString Bu::MiniMacro::parseCmd()
+Bu::String Bu::MiniMacro::parseCmd()
 {
-        Bu::FString sOut;
+        Bu::String sOut;
         const char *sNext = sCur;
         for(; *sNext != ':' && *sNext != '}' && *sNext != '\0'; sNext++ ) { }
         if( *sNext != '\0' )
         {
-                Bu::FString sName( sCur, (ptrdiff_t)sNext-(ptrdiff_t)sCur );
+                Bu::String sName( sCur, (ptrdiff_t)sNext-(ptrdiff_t)sCur );
                 if( sName == "end" )
                 {
                         sCur = sNext;
@@ -138,20 +138,20 @@ Bu::FString Bu::MiniMacro::parseCmd()
         return sOut;
 }
 
-Bu::FString Bu::MiniMacro::callFunc(
-        const Bu::FString &sIn, const Bu::FString &sFunc )
+Bu::String Bu::MiniMacro::callFunc(
+        const Bu::String &sIn, const Bu::String &sFunc )
 {
         int i = sFunc.findIdx('(');
         if( i < 0 )
                 throw Bu::ExceptionBase("That doesn't look like a function call");
-        Bu::FString sName( sFunc.getStr(), i );
+        Bu::String sName( sFunc.getStr(), i );
         StrList lsParams;
         for( const char *s = sFunc.getStr()+i+1; *s && *s != ')'; s++ )
         {
                 for(; *s == ' ' || *s == '\t' || *s == '\r' || *s == '\n'; s++ ) { }
                 const char *sNext;
                 for( sNext = s; *sNext && *sNext != ')' && *sNext != ','; sNext++ ) { }
-                Bu::FString p( s, (ptrdiff_t)sNext-(ptrdiff_t)s );
+                Bu::String p( s, (ptrdiff_t)sNext-(ptrdiff_t)s );
                 lsParams.append( p );
                 sNext++;
                 s = sNext;
@@ -160,17 +160,17 @@ Bu::FString Bu::MiniMacro::callFunc(
 }
 
 void Bu::MiniMacro::addVar(
-        const Bu::FString &sName, const Bu::FString &sValue )
+        const Bu::String &sName, const Bu::String &sValue )
 {
         hVars.insert( sName, sValue );
 }
 
-bool Bu::MiniMacro::hasVar( const Bu::FString &sName )
+bool Bu::MiniMacro::hasVar( const Bu::String &sName )
 {
         return hVars.has( sName );
 }
 
-const Bu::FString &Bu::MiniMacro::getVar( const Bu::FString &sName )
+const Bu::String &Bu::MiniMacro::getVar( const Bu::String &sName )
 {
         return hVars.get( sName );
 }
diff --git a/src/minimacro.h b/src/minimacro.h
index 2a1fe23..0483190 100644
--- a/src/minimacro.h
+++ b/src/minimacro.h
@@ -9,11 +9,11 @@
 #define BU_MINI_MACRO_H
 
 #include "bu/hash.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 namespace Bu
 {
-        typedef Bu::Hash<Bu::FString, Bu::FString> StrHash;
+        typedef Bu::Hash<Bu::String, Bu::String> StrHash;
         /**
          * A processor for Libbu++ brand Mini Macros.  These are really simple, but
          * still fairly flexible.  It's mainly text replacement, but with a few
@@ -67,34 +67,34 @@ namespace Bu
                 MiniMacro( const StrHash &sVarSrc );
                 virtual ~MiniMacro();
 
-                Bu::FString parse( const Bu::FString &sIn );
-                void addVar( const Bu::FString &sName, const Bu::FString &sValue );
-                bool hasVar( const Bu::FString &sName );
-                const Bu::FString &getVar( const Bu::FString &sName );
+                Bu::String parse( const Bu::String &sIn );
+                void addVar( const Bu::String &sName, const Bu::String &sValue );
+                bool hasVar( const Bu::String &sName );
+                const Bu::String &getVar( const Bu::String &sName );
                 const StrHash &getVars();
                 int getPosition();
 
         private:
                 const char *sCur;
-                Bu::FString parseRepl();
-                Bu::FString parseCond();
-                Bu::FString parseCmd();
-                Bu::FString callFunc(
-                        const Bu::FString &sIn, const Bu::FString &sFunc );
+                Bu::String parseRepl();
+                Bu::String parseCond();
+                Bu::String parseCmd();
+                Bu::String callFunc(
+                        const Bu::String &sIn, const Bu::String &sFunc );
 
                 StrHash hVars;
                 bool bContinue;
                 int iLastPos;
 
         public:
-                typedef Bu::List<Bu::FString> StrList;
+                typedef Bu::List<Bu::String> StrList;
                 class Func
                 {
                 public:
                         Func(){}
                         virtual ~Func(){}
-                        virtual Bu::FString call(
-                                const Bu::FString &sIn, StrList &lsParam )=0;
+                        virtual Bu::String call(
+                                const Bu::String &sIn, StrList &lsParam )=0;
                 };
 
                 class FuncToUpper : public Func
@@ -102,10 +102,10 @@ namespace Bu
                 public:
                         FuncToUpper(){}
                         virtual ~FuncToUpper(){}
-                        virtual Bu::FString call(
-                                const Bu::FString &sIn, StrList & )
+                        virtual Bu::String call(
+                                const Bu::String &sIn, StrList & )
                         {
-                                Bu::FString sOut( sIn );
+                                Bu::String sOut( sIn );
                                 sOut.toUpper();
                                 return sOut;
                         }
@@ -116,17 +116,17 @@ namespace Bu
                 public:
                         FuncToLower(){}
                         virtual ~FuncToLower(){}
-                        virtual Bu::FString call(
-                                const Bu::FString &sIn, StrList & )
+                        virtual Bu::String call(
+                                const Bu::String &sIn, StrList & )
                         {
-                                Bu::FString sOut( sIn );
+                                Bu::String sOut( sIn );
                                 sOut.toLower();
                                 return sOut;
                         }
                 };
                 
         private:
-                typedef Bu::Hash<Bu::FString,class Func *> FuncHash;
+                typedef Bu::Hash<Bu::String,class Func *> FuncHash;
                 FuncHash hFuncs;
         };
 };
diff --git a/src/multiserver.cpp b/src/multiserver.cpp
index a6cee36..58f2a7c 100644
--- a/src/multiserver.cpp
+++ b/src/multiserver.cpp
@@ -26,7 +26,7 @@ void Bu::MultiServer::addProtocol( Bu::Protocol *(*proc)(), int iPort,
         addPort( iPort, nPoolSize );
 }
 
-void Bu::MultiServer::addProtocol( Protocol *(*proc)(), const FString &sAddr,
+void Bu::MultiServer::addProtocol( Protocol *(*proc)(), const String &sAddr,
         int iPort, int nPoolSize )
 {
         hProtos[iPort] = proc;
diff --git a/src/multiserver.h b/src/multiserver.h
index 6b98c1d..d529d0c 100644
--- a/src/multiserver.h
+++ b/src/multiserver.h
@@ -29,7 +29,7 @@ namespace Bu
                 virtual ~MultiServer();
 
                 void addProtocol( Protocol *(*proc)(), int iPort, int nPoolSize=40 );
-                void addProtocol( Protocol *(*proc)(), const FString &sAddr, int iPort,
+                void addProtocol( Protocol *(*proc)(), const String &sAddr, int iPort,
                                 int nPoolSize=40 );
                 
                 void scan()
diff --git a/src/nullstream.cpp b/src/nullstream.cpp
index 40c636c..6f792e3 100644
--- a/src/nullstream.cpp
+++ b/src/nullstream.cpp
@@ -22,10 +22,10 @@ size_t Bu::NullStream::read( void *pBuf, size_t nBytes )
         return nBytes;
 }
 
-Bu::FString Bu::NullStream::readLine()
+Bu::String Bu::NullStream::readLine()
 {
         sRead++;
-        return Bu::FString("\0", 1 );
+        return Bu::String("\0", 1 );
 }
 
 size_t Bu::NullStream::write( const void *, size_t nBytes )
diff --git a/src/nullstream.h b/src/nullstream.h
index 1537ffb..8c1f744 100644
--- a/src/nullstream.h
+++ b/src/nullstream.h
@@ -25,7 +25,7 @@ namespace Bu
 
                 virtual void close();
                 virtual size_t read( void *pBuf, size_t nBytes );
-                virtual Bu::FString readLine();
+                virtual Bu::String readLine();
                 virtual size_t write( const void *pBuf, size_t nBytes );
                 using Bu::Stream::write;
                 virtual long tell();
diff --git a/src/optparser.cpp b/src/optparser.cpp
index b81691d..7b4e0d0 100644
--- a/src/optparser.cpp
+++ b/src/optparser.cpp
@@ -32,9 +32,9 @@ void Bu::OptParser::parse( int argc, char **argv )
                                 for( iEPos = 2; argv[j][iEPos] != '\0' &&
                                          argv[j][iEPos] != '='; iEPos++ ) { }
 
-                                Bu::FString sOpt;
+                                Bu::String sOpt;
                                 int iCount = argc-j;
-                                Bu::FString sExtraParam;
+                                Bu::String sExtraParam;
                                 if( argv[j][iEPos] == '=' )
                                 {
                                         sOpt.set( argv[j]+2, iEPos-2 );
@@ -92,7 +92,7 @@ void Bu::OptParser::parse( int argc, char **argv )
                                 {
                                         if( !hsOption.has( argv[j][iCPos] ) )
                                         {
-                                                Bu::FString sOpt("-");
+                                                Bu::String sOpt("-");
                                                 sOpt += argv[j][iCPos];
                                                 optionError( sOpt );
                                         }
@@ -181,17 +181,17 @@ void Bu::OptParser::setOverride( char cOpt, const Bu::Variant &sOverride )
         hsOption.get( cOpt )->sOverride = sOverride;
 }
 
-void Bu::OptParser::setOverride( const Bu::FString &sOpt, const Bu::Variant &sOverride )
+void Bu::OptParser::setOverride( const Bu::String &sOpt, const Bu::Variant &sOverride )
 {
         hlOption.get( sOpt )->sOverride = sOverride;
 }
 
-void Bu::OptParser::setHelpDefault( const Bu::FString &sOpt, const Bu::FString &sTxt )
+void Bu::OptParser::setHelpDefault( const Bu::String &sOpt, const Bu::String &sTxt )
 {
         hlOption.get( sOpt )->sHelpDefault = sTxt;
 }
 
-void Bu::OptParser::addHelpOption( char c, const Bu::FString &s, const Bu::FString &sHelp )
+void Bu::OptParser::addHelpOption( char c, const Bu::String &s, const Bu::String &sHelp )
 {
         Option o;
         o.sUsed = slot( this, &OptParser::optHelp );
@@ -201,7 +201,7 @@ void Bu::OptParser::addHelpOption( char c, const Bu::FString &s, const Bu::FStri
         addOption( o );
 }
 
-void Bu::OptParser::addHelpBanner( const Bu::FString &sText, bool bFormatted )
+void Bu::OptParser::addHelpBanner( const Bu::String &sText, bool bFormatted )
 {
         Banner b;
         b.sText = sText;
@@ -290,7 +290,7 @@ int Bu::OptParser::optHelp( StrArray /*aParams*/ )
         return 0;
 }
 
-void Bu::OptParser::optionError( const Bu::FString &sOption )
+void Bu::OptParser::optionError( const Bu::String &sOption )
 {
         sio << "Unregcognized option discovered: " << sOption << sio.nl << sio.nl;
         exit( 1 );
@@ -301,11 +301,11 @@ void Bu::OptParser::setNonOption( OptionSignal sSignal )
         sNonOption = sSignal;
 }
 
-Bu::FString Bu::OptParser::format( const Bu::FString &sIn, int iWidth,
+Bu::String Bu::OptParser::format( const Bu::String &sIn, int iWidth,
                 int iIndent )
 {
-        Bu::FString sOut;
-        Bu::FString sIndent;
+        Bu::String sOut;
+        Bu::String sIndent;
         for( int j = 0; j < iIndent; j++ )
                 sIndent.append(" ", 1);
         bool bFirst = true;
@@ -314,8 +314,8 @@ Bu::FString Bu::OptParser::format( const Bu::FString &sIn, int iWidth,
         int iPrevLineLen;
         int iLineLen = 0;
         char c;
-        Bu::FString::const_iterator iLastSpace, iStart;
-        for( Bu::FString::const_iterator i = iLastSpace = iStart = sIn.begin(); i; i++ )
+        Bu::String::const_iterator iLastSpace, iStart;
+        for( Bu::String::const_iterator i = iLastSpace = iStart = sIn.begin(); i; i++ )
         {
                 c = *i;
                 if( *i == ' ' )
@@ -346,7 +346,7 @@ Bu::FString Bu::OptParser::format( const Bu::FString &sIn, int iWidth,
                         float fFill = 0.0;
                         int iSubSpaceCount = 0;
                         float fAdd = ((float)iExtraSpaces/(float)iSpaceCount);
-                        for( Bu::FString::const_iterator k = iStart; k != iLastSpace; k++ )
+                        for( Bu::String::const_iterator k = iStart; k != iLastSpace; k++ )
                         {
                                 sOut += *k;
                                 if( *k == ' ' )
diff --git a/src/optparser.h b/src/optparser.h
index 7ec69e5..9781542 100644
--- a/src/optparser.h
+++ b/src/optparser.h
@@ -8,7 +8,7 @@
 #ifndef BU_OPT_PARSER_H
 #define BU_OPT_PARSER_H
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/list.h"
 #include "bu/hash.h"
 #include "bu/signals.h"
@@ -19,7 +19,7 @@
 
 namespace Bu
 {
-        typedef Bu::Array<Bu::FString> StrArray;
+        typedef Bu::Array<Bu::String> StrArray;
 
         /**
          * POSIX/Gnu style command line parser.  Handles long and short options in
@@ -41,7 +41,7 @@ namespace Bu
                         _ValueProxy();
                         virtual ~_ValueProxy();
 
-                        virtual void setValueFromStr( const Bu::FString & )=0;
+                        virtual void setValueFromStr( const Bu::String & )=0;
                         virtual void setValue( const Bu::Variant &vVar )=0;
                         virtual _ValueProxy *clone()=0;
                 };
@@ -59,7 +59,7 @@ namespace Bu
                         {
                         }
 
-                        virtual void setValueFromStr( const Bu::FString &sVal )
+                        virtual void setValueFromStr( const Bu::String &sVal )
                         {
                                 Bu::MemBuf mb( sVal );
                                 Bu::Formatter f( mb );
@@ -72,9 +72,9 @@ namespace Bu
                                 {
                                         v = vVar.get<ptype>();
                                 }
-                                else if( vVar.getType() == typeid(Bu::FString) )
+                                else if( vVar.getType() == typeid(Bu::String) )
                                 {
-                                        setValueFromStr( vVar.get<Bu::FString>() );
+                                        setValueFromStr( vVar.get<Bu::String>() );
                                 }
                                 else
                                 {
@@ -101,23 +101,23 @@ namespace Bu
                         virtual ~Option();
 
                         char cOpt;
-                        Bu::FString sOpt;
-                        Bu::FString sHelp;
+                        Bu::String sOpt;
+                        Bu::String sHelp;
                         OptionSignal sUsed;
                         _ValueProxy *pProxy;
                         Bu::Variant sOverride;
-                        Bu::FString sHelpDefault;
+                        Bu::String sHelpDefault;
                 };
         
         private:
                 typedef Bu::List<Option> OptionList;
                 typedef Bu::Hash<char, Option *> ShortOptionHash;
-                typedef Bu::Hash<Bu::FString, Option *> LongOptionHash;
+                typedef Bu::Hash<Bu::String, Option *> LongOptionHash;
                 
                 class Banner
                 {
                 public:
-                        Bu::FString sText;
+                        Bu::String sText;
                         bool bFormatted;
                         OptionList::const_iterator iAfter;
                 };
@@ -133,8 +133,8 @@ namespace Bu
                 void addOption( const Option &opt );
                 
                 template<typename vtype>
-                void addOption( vtype &var, char cOpt, const Bu::FString &sOpt,
-                                const Bu::FString &sHelp )
+                void addOption( vtype &var, char cOpt, const Bu::String &sOpt,
+                                const Bu::String &sHelp )
                 {
                         Option o;
                         o.cOpt = cOpt;
@@ -145,20 +145,20 @@ namespace Bu
                 }
                 
                 template<typename vtype>
-                void addOption( vtype &var, const Bu::FString &sOpt,
-                                const Bu::FString &sHelp )
+                void addOption( vtype &var, const Bu::String &sOpt,
+                                const Bu::String &sHelp )
                 {
                         addOption( var, '\0', sOpt, sHelp );
                 }
                 
                 template<typename vtype>
-                void addOption( vtype &var, char cOpt, const Bu::FString &sHelp )
+                void addOption( vtype &var, char cOpt, const Bu::String &sHelp )
                 {
                         addOption( var, cOpt, "", sHelp );
                 }
 
-                void addOption( OptionSignal sUsed, char cOpt, const Bu::FString &sOpt,
-                                const Bu::FString &sHelp )
+                void addOption( OptionSignal sUsed, char cOpt, const Bu::String &sOpt,
+                                const Bu::String &sHelp )
                 {
                         Option o;
                         o.cOpt = cOpt;
@@ -168,27 +168,27 @@ namespace Bu
                         addOption( o );
                 }
                 
-                void addOption( OptionSignal sUsed, const Bu::FString &sOpt,
-                                const Bu::FString &sHelp )
+                void addOption( OptionSignal sUsed, const Bu::String &sOpt,
+                                const Bu::String &sHelp )
                 {
                         addOption( sUsed, '\0', sOpt, sHelp );
                 }
                 
                 void addOption( OptionSignal sUsed, char cOpt,
-                                const Bu::FString &sHelp )
+                                const Bu::String &sHelp )
                 {
                         addOption( sUsed, cOpt, "", sHelp );
                 }
 
                 void setOverride( char cOpt, const Bu::Variant &sOverride );
-                void setOverride( const Bu::FString &sOpt,
+                void setOverride( const Bu::String &sOpt,
                                 const Bu::Variant &sOverride );
 
-                void setHelpDefault( const Bu::FString &sOpt, const Bu::FString &sTxt );
+                void setHelpDefault( const Bu::String &sOpt, const Bu::String &sTxt );
                 
-                void addHelpOption( char c='h', const Bu::FString &s="help",
-                                const Bu::FString &sHelp="This help." );
-                void addHelpBanner( const Bu::FString &sText, bool bFormatted=true );
+                void addHelpOption( char c='h', const Bu::String &s="help",
+                                const Bu::String &sHelp="This help." );
+                void addHelpBanner( const Bu::String &sText, bool bFormatted=true );
 
                 int optHelp( StrArray aParams );
 
@@ -200,12 +200,12 @@ namespace Bu
                  * been handled by an option, and isn't an option (starts with - or --).
                  * To change this behaviour call 
                  */
-                virtual void optionError( const Bu::FString &sOption );
+                virtual void optionError( const Bu::String &sOption );
 
                 void setNonOption( OptionSignal sSignal );
 
         private:
-                Bu::FString format( const Bu::FString &sIn, int iWidth, int iIndent );
+                Bu::String format( const Bu::String &sIn, int iWidth, int iIndent );
 
                 OptionList lOption;
                 ShortOptionHash hsOption;
diff --git a/src/parser.cpp b/src/parser.cpp
index 4ad4ff9..e46967c 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -172,12 +172,12 @@ void Bu::Parser::setRootNonTerminal( int iRoot )
         iRootNonTerminal = iRoot;
 }
 
-void Bu::Parser::setRootNonTerminal( const Bu::FString &sRoot )
+void Bu::Parser::setRootNonTerminal( const Bu::String &sRoot )
 {
         setRootNonTerminal( hNonTerminalName.get( sRoot ) );
 }
 
-int Bu::Parser::addNonTerminal( const Bu::FString &sName, NonTerminal &nt )
+int Bu::Parser::addNonTerminal( const Bu::String &sName, NonTerminal &nt )
 {
         int iId = aNonTerminal.getSize();
         aNonTerminal.append( nt );
@@ -186,7 +186,7 @@ int Bu::Parser::addNonTerminal( const Bu::FString &sName, NonTerminal &nt )
         return iId;
 }
 
-int Bu::Parser::addNonTerminal( const Bu::FString &sName )
+int Bu::Parser::addNonTerminal( const Bu::String &sName )
 {
         int iId = aNonTerminal.getSize();
         aNonTerminal.append( NonTerminal() );
@@ -195,22 +195,22 @@ int Bu::Parser::addNonTerminal( const Bu::FString &sName )
         return iId;
 }
 
-void Bu::Parser::setNonTerminal( const Bu::FString &sName, NonTerminal &nt )
+void Bu::Parser::setNonTerminal( const Bu::String &sName, NonTerminal &nt )
 {
         aNonTerminal[hNonTerminalName.get(sName)] = nt;
 }
 
-int Bu::Parser::getNonTerminalId( const Bu::FString &sName )
+int Bu::Parser::getNonTerminalId( const Bu::String &sName )
 {
         return hNonTerminalName.get( sName );
 }
 
-bool Bu::Parser::hasNonTerminal( const Bu::FString &sName )
+bool Bu::Parser::hasNonTerminal( const Bu::String &sName )
 {
         return hNonTerminalName.has( sName );
 }
 
-int Bu::Parser::addReduction( const Bu::FString &sName, const Reduction &r )
+int Bu::Parser::addReduction( const Bu::String &sName, const Reduction &r )
 {
         int iId = aReduction.getSize();
         aReduction.append( r );
@@ -218,7 +218,7 @@ int Bu::Parser::addReduction( const Bu::FString &sName, const Reduction &r )
         return iId;
 }
 
-int Bu::Parser::addReduction( const Bu::FString &sName )
+int Bu::Parser::addReduction( const Bu::String &sName )
 {
         int iId = aReduction.getSize();
         aReduction.append( Reduction() );
@@ -226,17 +226,17 @@ int Bu::Parser::addReduction( const Bu::FString &sName )
         return iId;
 }
 
-void Bu::Parser::setReduction( const Bu::FString &sName, const Reduction &r )
+void Bu::Parser::setReduction( const Bu::String &sName, const Reduction &r )
 {
         aReduction[hReductionName.get(sName)] = r;
 }
 
-int Bu::Parser::getReductionId( const Bu::FString &sName )
+int Bu::Parser::getReductionId( const Bu::String &sName )
 {
         return hReductionName.get( sName );
 }
 
-bool Bu::Parser::hasReduction( const Bu::FString &sName )
+bool Bu::Parser::hasReduction( const Bu::String &sName )
 {
         return hReductionName.has( sName );
 }
diff --git a/src/parser.h b/src/parser.h
index a925188..f4c4a74 100644
--- a/src/parser.h
+++ b/src/parser.h
@@ -1,7 +1,7 @@
 #ifndef BU_PARSER_H
 #define BU_PARSER_H
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/list.h"
 #include "bu/array.h"
 #include "bu/hash.h"
@@ -43,7 +43,7 @@ namespace Bu
                 void parse();
 
                 void setRootNonTerminal( int iRoot );
-                void setRootNonTerminal( const Bu::FString &sRoot );
+                void setRootNonTerminal( const Bu::String &sRoot );
 
                 typedef Bu::Signal1<void, Parser &> Reduction;
 
@@ -87,17 +87,17 @@ namespace Bu
                         bool bCanSkip;
                 };
 
-                int addNonTerminal( const Bu::FString &sName, NonTerminal &nt );
-                int addNonTerminal( const Bu::FString &sName );
-                void setNonTerminal( const Bu::FString &sName, NonTerminal &nt );
-                int getNonTerminalId( const Bu::FString &sName );
-                bool hasNonTerminal( const Bu::FString &sName );
+                int addNonTerminal( const Bu::String &sName, NonTerminal &nt );
+                int addNonTerminal( const Bu::String &sName );
+                void setNonTerminal( const Bu::String &sName, NonTerminal &nt );
+                int getNonTerminalId( const Bu::String &sName );
+                bool hasNonTerminal( const Bu::String &sName );
 
-                int addReduction( const Bu::FString &sName, const Reduction &r );
-                int addReduction( const Bu::FString &sName );
-                void setReduction( const Bu::FString &sName, const Reduction &r );
-                int getReductionId( const Bu::FString &sName );
-                bool hasReduction( const Bu::FString &sName );
+                int addReduction( const Bu::String &sName, const Reduction &r );
+                int addReduction( const Bu::String &sName );
+                void setReduction( const Bu::String &sName, const Reduction &r );
+                int getReductionId( const Bu::String &sName );
+                bool hasReduction( const Bu::String &sName );
 
         private:
                 bool selectProduction( int iNt, Lexer::Token *ptCur );
@@ -108,7 +108,7 @@ namespace Bu
                 typedef Bu::List<Lexer::Token *> TokenStack;
                 typedef Bu::List<Production::const_iterator> StateStack;
                 typedef Bu::Array<Reduction> ReductionArray;
-                typedef Bu::Hash<Bu::FString,int> NameIndexHash;
+                typedef Bu::Hash<Bu::String,int> NameIndexHash;
                 typedef Bu::Array<NonTerminal> NonTerminalArray;
 
                 LexerStack sLexer;
diff --git a/src/plugger.h b/src/plugger.h
index 9a74029..ef0cb53 100644
--- a/src/plugger.h
+++ b/src/plugger.h
@@ -14,7 +14,7 @@
 #include "bu/list.h"
 #include <dlfcn.h>
 #include "bu/exceptionbase.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include <stddef.h>
 
 namespace Bu
@@ -89,7 +89,7 @@ namespace Bu
         class Plugger
         {
         public:
-                typedef Bu::Hash<Bu::FString, PluginReg *> PluginHash;
+                typedef Bu::Hash<Bu::String, PluginReg *> PluginHash;
                 typedef Bu::Hash<ptrdiff_t, void *> InstHash;
 
         public:
@@ -125,8 +125,8 @@ namespace Bu
                         hPlugin.insert( pInfo->sID, pReg );
                 }
 
-                void registerExternalPlugin( const Bu::FString &sFName,
-                                const Bu::FString &sPluginName )
+                void registerExternalPlugin( const Bu::String &sFName,
+                                const Bu::String &sPluginName )
                 {
                         PluginReg *pReg;
                         try {
@@ -158,7 +158,7 @@ namespace Bu
                         hPlugin.insert( pReg->pInfo->sID, pReg );
                 }
 
-                T *instantiate( const Bu::FString &lpName )
+                T *instantiate( const Bu::String &lpName )
                 {
                         PluginReg *pReg = (PluginReg *)hPlugin[lpName];
                         if( pReg == NULL )
@@ -171,7 +171,7 @@ namespace Bu
                         return p;
                 }
 
-                bool hasPlugin( const Bu::FString &lpName )
+                bool hasPlugin( const Bu::String &lpName )
                 {
                         return hPlugin.has( lpName );
                 }
@@ -202,7 +202,7 @@ namespace Bu
                         hPlugin.clear();
                 }
 
-                Bu::List<Bu::FString> getPluginList()
+                Bu::List<Bu::String> getPluginList()
                 {
                         return hPlugin.getKeys();
                 }
diff --git a/src/process.h b/src/process.h
index 68678bd..d787854 100644
--- a/src/process.h
+++ b/src/process.h
@@ -12,7 +12,7 @@
 #include <sys/types.h>
 
 #include "bu/stream.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 namespace Bu
 {
diff --git a/src/protocol.cpp b/src/protocol.cpp
index 28d8c08..7e992b4 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -25,7 +25,7 @@ void Bu::Protocol::onNewData( Bu::Client * )
 {
 }
 
-void Bu::Protocol::onMessage( Bu::Client *, const Bu::FString & )
+void Bu::Protocol::onMessage( Bu::Client *, const Bu::String & )
 {
 }
 
diff --git a/src/protocol.h b/src/protocol.h
index f462060..28a70d0 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -10,7 +10,7 @@
 
 #include <stdint.h>
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 namespace Bu
 {
@@ -27,7 +27,7 @@ namespace Bu
 
                 virtual void onNewConnection( Bu::Client *pClient );
                 virtual void onNewData( Bu::Client *pClient );
-                virtual void onMessage( Bu::Client *pClient, const Bu::FString &sMsg );
+                virtual void onMessage( Bu::Client *pClient, const Bu::String &sMsg );
                 virtual void onTick( Bu::Client *pClient );
 
         private:
diff --git a/src/protocolhttp.cpp b/src/protocolhttp.cpp
index 2a7fbdf..2fe447a 100644
--- a/src/protocolhttp.cpp
+++ b/src/protocolhttp.cpp
@@ -51,7 +51,7 @@ void Bu::ProtocolHttp::onNewData( Bu::Client *pClient )
 
         for(;;)
         {
-                Bu::FString sToken;
+                Bu::String sToken;
                 TokenType tt = getToken( sToken );
 
                 if( tt == ttOutOfData )
@@ -148,7 +148,7 @@ void Bu::ProtocolHttp::onNewData( Bu::Client *pClient )
         }
 }
 
-Bu::ProtocolHttp::TokenType Bu::ProtocolHttp::getToken( Bu::FString &line )
+Bu::ProtocolHttp::TokenType Bu::ProtocolHttp::getToken( Bu::String &line )
 {
         char s;
         int jmax = pClient->getInputSize();
@@ -330,7 +330,7 @@ Bu::ProtocolHttp::Response::Response( int iCode ) :
         }
 }
 
-Bu::ProtocolHttp::Response::Response( int iCode, const Bu::FString &sReason ) :
+Bu::ProtocolHttp::Response::Response( int iCode, const Bu::String &sReason ) :
         iCode( iCode ),
         sReason( sReason )
 {
@@ -341,12 +341,12 @@ Bu::ProtocolHttp::Response::~Response()
 }
 
 void Bu::ProtocolHttp::Response::setHeader(
-        const Bu::FString &sKey, const Bu::FString &sVal )
+        const Bu::String &sKey, const Bu::String &sVal )
 {
         hHeaders.insert( sKey, sVal );
 }
 
-void Bu::ProtocolHttp::Response::setContent( const Bu::FString &sCont )
+void Bu::ProtocolHttp::Response::setContent( const Bu::String &sCont )
 {
         sContent = sCont;
 }
diff --git a/src/protocolhttp.h b/src/protocolhttp.h
index 80a0db6..6f4af9b 100644
--- a/src/protocolhttp.h
+++ b/src/protocolhttp.h
@@ -13,7 +13,7 @@
 
 #include "bu/protocol.h"
 #include "bu/client.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/hash.h"
 
 namespace Bu
@@ -32,7 +32,7 @@ namespace Bu
         class ProtocolHttp : public Protocol
         {
         public: /* Types */
-                typedef Bu::List<Bu::FString> TokenList;
+                typedef Bu::List<Bu::String> TokenList;
 
         public: /* Interface */
                 ProtocolHttp();
@@ -42,25 +42,25 @@ namespace Bu
                 virtual void onNewData( Bu::Client *pClient );
 
                 virtual void onRequest(
-                        const Bu::FString &sMethod, const Bu::FString &sPath )=0;
+                        const Bu::String &sMethod, const Bu::String &sPath )=0;
 
                 class Response
                 {
                         friend class Bu::ProtocolHttp;
                 public:
                         Response( int iCode );
-                        Response( int iCode, const Bu::FString &sReason );
+                        Response( int iCode, const Bu::String &sReason );
                         virtual ~Response();
 
-                        void setHeader( const Bu::FString &sKey, const Bu::FString &sVal );
-                        void setContent( const Bu::FString &sCont );
+                        void setHeader( const Bu::String &sKey, const Bu::String &sVal );
+                        void setContent( const Bu::String &sCont );
 
                 private:
                         int iCode;
-                        Bu::FString sReason;
-                        typedef Bu::Hash<Bu::FString,Bu::FString> StringHash;
+                        Bu::String sReason;
+                        typedef Bu::Hash<Bu::String,Bu::String> StringHash;
                         StringHash hHeaders;
-                        Bu::FString sContent;
+                        Bu::String sContent;
                 };
                 
                 void sendResponse( const Response &rRes );
@@ -83,7 +83,7 @@ namespace Bu
                  * processed, false if the end-of-line has not been reached, and more
                  * data needs to be read before this operation can continue.
                  */
-                TokenType getToken( Bu::FString &line );
+                TokenType getToken( Bu::String &line );
                 bool isWS( char buf );
                 bool isSeperator( char buf );
 
@@ -96,8 +96,8 @@ namespace Bu
 
                 int iState;
 
-                Bu::FString sMethod;
-                Bu::FString sPath;
+                Bu::String sMethod;
+                Bu::String sPath;
                 int iMajor;
                 int iMinor;
         };
diff --git a/src/protocoltelnet.cpp b/src/protocoltelnet.cpp
index 362b1cc..e07f275 100644
--- a/src/protocoltelnet.cpp
+++ b/src/protocoltelnet.cpp
@@ -273,7 +273,7 @@ bool Bu::ProtocolTelnet::isCanonical()
         return bCanonical;
 }
 
-void Bu::ProtocolTelnet::write( const Bu::FString &sData )
+void Bu::ProtocolTelnet::write( const Bu::String &sData )
 {
         write( sData.getStr(), sData.getSize() );
 }
diff --git a/src/protocoltelnet.h b/src/protocoltelnet.h
index 253be79..e7a9af1 100644
--- a/src/protocoltelnet.h
+++ b/src/protocoltelnet.h
@@ -10,7 +10,7 @@
 
 #include "bu/protocol.h"
 #include "bu/hash.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 // #define __TELNET_DEBUG
 
@@ -88,7 +88,7 @@ namespace Bu
                  * the line or not, the data will be cleared from the buffer when this
                  * function returns, any changes made to the buffer will be destroyed.
                  */
-                virtual void gotLine( Bu::FString & /*sLine*/ ){};
+                virtual void gotLine( Bu::String & /*sLine*/ ){};
 
                 /**
                  * Override this function to be notified of any new data that comes in
@@ -98,7 +98,7 @@ namespace Bu
                  * child class in this function, the buffer will never be cleared unless
                  * it happens in this function's override.
                  */
-                virtual void gotData( Bu::FString & /*sData*/ ){};
+                virtual void gotData( Bu::String & /*sData*/ ){};
 
                 /**
                  * Using this function to enable or disable canonical mode only affects
@@ -117,11 +117,11 @@ namespace Bu
                 void setCanonical( bool bCon=true );
                 bool isCanonical();
 
-                void write( const Bu::FString &sData );
+                void write( const Bu::String &sData );
                 void write( const char *pData, int iSize );
                 void write( char cData );
 
-                const Bu::FString &getBuffer() { return sDataBuf; }
+                const Bu::String &getBuffer() { return sDataBuf; }
 
         public:
                 /**
@@ -138,7 +138,7 @@ namespace Bu
                  * sSubBuf, it will be cleared as soon as this function returns anyway.
                  */
                 virtual void onSubUnknown( char /*cSubOpt*/,
-                        Bu::FString & /*sSubBuf*/ ){};
+                        Bu::String & /*sSubBuf*/ ){};
 
         private:
                 /**
@@ -208,8 +208,8 @@ namespace Bu
         private:
                 Client *pClient;
 
-                Bu::FString sDataBuf;   /**< Buffer for regular line data. */
-                Bu::FString sSubBuf;    /**< Buffer for subnegotiation data. */
+                Bu::String sDataBuf;    /**< Buffer for regular line data. */
+                Bu::String sSubBuf;     /**< Buffer for subnegotiation data. */
                 char cSubOpt;   /**< Which suboption are we processing. */
 
                 bool bCanonical;        /**< Are we canonicalizing incoming data? */
diff --git a/src/regex.cpp b/src/regex.cpp
index e634639..8c28333 100644
--- a/src/regex.cpp
+++ b/src/regex.cpp
@@ -19,7 +19,7 @@ Bu::RegEx::RegEx() :
 {
 }
 
-Bu::RegEx::RegEx( const Bu::FString &sSrc ) :
+Bu::RegEx::RegEx( const Bu::String &sSrc ) :
         pRegEx( NULL ),
         bCompiled( false ),
         paSubStr( NULL )
@@ -37,7 +37,7 @@ Bu::RegEx::~RegEx()
         }
 }
 
-void Bu::RegEx::compile( const Bu::FString &sSrc )
+void Bu::RegEx::compile( const Bu::String &sSrc )
 {
         if( bCompiled )
         {
@@ -54,7 +54,7 @@ void Bu::RegEx::compile( const Bu::FString &sSrc )
                 size_t length = regerror( nErr, re, NULL, 0 );
                 char *buffer = new char[length];
                 (void) regerror( nErr, re, buffer, length );
-                Bu::FString s( buffer );
+                Bu::String s( buffer );
                 delete[] buffer;
                 throw "???"; // BuildException( s.getStr() );
         }
@@ -70,7 +70,7 @@ int Bu::RegEx::getNumSubStrings()
         return nSubStr;
 }
 
-bool Bu::RegEx::execute( const Bu::FString &sSrc )
+bool Bu::RegEx::execute( const Bu::String &sSrc )
 {
         sTest = sSrc;
         if( regexec( re, sSrc.getStr(), nSubStr, aSubStr, 0 ) )
@@ -84,10 +84,10 @@ void Bu::RegEx::getSubStringRange( int nIndex, int &iStart, int &iEnd )
         iEnd = aSubStr[nIndex].rm_eo;
 }
 
-Bu::FString Bu::RegEx::getSubString( int nIndex )
+Bu::String Bu::RegEx::getSubString( int nIndex )
 {
 //      regmatch_t *Subs = aSubStr;
-        return Bu::FString(
+        return Bu::String(
                 sTest.getStr()+aSubStr[nIndex].rm_so,
                 aSubStr[nIndex].rm_eo - aSubStr[nIndex].rm_so
                 );
diff --git a/src/regex.h b/src/regex.h
index 6aac8e3..06b6352 100644
--- a/src/regex.h
+++ b/src/regex.h
@@ -8,7 +8,7 @@
 #ifndef BU_REG_EX_H
 #define BU_REG_EX_H
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 #include <stdint.h>
 
@@ -18,22 +18,22 @@ namespace Bu
         {
         public:
                 RegEx();
-                RegEx( const Bu::FString &sSrc );
+                RegEx( const Bu::String &sSrc );
                 virtual ~RegEx();
 
-                void compile( const Bu::FString &sSrc );
+                void compile( const Bu::String &sSrc );
                 int getNumSubStrings();
-                bool execute( const Bu::FString &sSrc );
+                bool execute( const Bu::String &sSrc );
                 void getSubStringRange( int nIndex, int &iStart, int &iEnd );
-                Bu::FString getSubString( int nIndex );
-                const Bu::FString &getSource()
+                Bu::String getSubString( int nIndex );
+                const Bu::String &getSource()
                 {
                         return sSrc;
                 }
 
         private:
-                Bu::FString sSrc;
-                Bu::FString sTest;
+                Bu::String sSrc;
+                Bu::String sTest;
                 void *pRegEx;
                 bool bCompiled;
                 int nSubStr;
diff --git a/src/server.cpp b/src/server.cpp
index e701a69..3348d3c 100644
--- a/src/server.cpp
+++ b/src/server.cpp
@@ -34,7 +34,7 @@ void Bu::Server::addPort( int nPort, int nPoolSize )
         hServers.insert( nSocket, s );
 }
 
-void Bu::Server::addPort( const FString &sAddr, int nPort, int nPoolSize )
+void Bu::Server::addPort( const String &sAddr, int nPort, int nPoolSize )
 {
         TcpServerSocket *s = new TcpServerSocket( sAddr, nPort, nPoolSize );
         int nSocket = s->getSocket();
@@ -153,7 +153,7 @@ Bu::Server::SrvClientLink::~SrvClientLink()
 {
 }
 
-void Bu::Server::SrvClientLink::sendMessage( const Bu::FString &sMsg )
+void Bu::Server::SrvClientLink::sendMessage( const Bu::String &sMsg )
 {
         pClient->onMessage( sMsg );
 }
diff --git a/src/server.h b/src/server.h
index d6726fd..f22d01b 100644
--- a/src/server.h
+++ b/src/server.h
@@ -14,7 +14,7 @@
         #include <sys/select.h>
 #endif
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/list.h"
 
 #include "bu/clientlink.h"
@@ -56,7 +56,7 @@ namespace Bu
                 virtual ~Server();
 
                 void addPort( int nPort, int nPoolSize=40 );
-                void addPort( const FString &sAddr, int nPort, int nPoolSize=40 );
+                void addPort( const String &sAddr, int nPort, int nPoolSize=40 );
 
                 virtual void scan();
                 void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 );
@@ -79,7 +79,7 @@ namespace Bu
                         SrvClientLink( Bu::Client *pClient );
                         virtual ~SrvClientLink();
 
-                        virtual void sendMessage( const Bu::FString &sMsg );
+                        virtual void sendMessage( const Bu::String &sMsg );
 
                 private:
                         Bu::Client *pClient;
diff --git a/src/sha1.cpp b/src/sha1.cpp
index a206a78..f3e4eb1 100644
--- a/src/sha1.cpp
+++ b/src/sha1.cpp
@@ -38,7 +38,7 @@ void Bu::Sha1::reset()
         uTotalBytes = 0;

 }

 

-void Bu::Sha1::setSalt( const Bu::FString & /*sSalt*/ )

+void Bu::Sha1::setSalt( const Bu::String & /*sSalt*/ )

 {

 }

 

@@ -73,7 +73,7 @@ void Bu::Sha1::addData( const void *sDataRaw, int iSize )
         }

 }

 

-Bu::FString Bu::Sha1::getResult()

+Bu::String Bu::Sha1::getResult()

 {

         // save the message size

         uint32_t totalBitsL = uTotalBytes << 3;

@@ -102,7 +102,7 @@ Bu::FString Bu::Sha1::getResult()
         // finish the final block

         addData( (char*)footer, iNeededZeros + 8 );

 

-        Bu::FString sRet( 20 );

+        Bu::String sRet( 20 );

 

         unsigned char *digest = (unsigned char *)sRet.getStr();

 

diff --git a/src/sha1.h b/src/sha1.h
index ea8c256..dbd1aa1 100644
--- a/src/sha1.h
+++ b/src/sha1.h
@@ -26,10 +26,10 @@ namespace Bu
                 ~Sha1();

 

                 virtual void reset();

-                virtual void setSalt( const Bu::FString &sSalt );

+                virtual void setSalt( const Bu::String &sSalt );

                 virtual void addData( const void *sData, int iSize );

                 using CryptoHash::addData;

-                virtual FString getResult();

+                virtual String getResult();

                 virtual void writeResult( Stream &sOut );

 

                 void update( const char* data, int num );

diff --git a/src/stream.cpp b/src/stream.cpp
index f13d33a..33817de 100644
--- a/src/stream.cpp
+++ b/src/stream.cpp
@@ -15,9 +15,9 @@ Bu::Stream::~Stream()
 {
 }
 
-Bu::FString Bu::Stream::readLine()
+Bu::String Bu::Stream::readLine()
 {
-        Bu::FString sRet;
+        Bu::String sRet;
         
         for(;;)
         {
@@ -30,7 +30,7 @@ Bu::FString Bu::Stream::readLine()
         }
 }
 
-Bu::size Bu::Stream::write( const Bu::FString &sBuf )
+Bu::size Bu::Stream::write( const Bu::String &sBuf )
 {
         return write( sBuf.getStr(), sBuf.getSize() );
 }
diff --git a/src/stream.h b/src/stream.h
index e7db7af..abbc9e8 100644
--- a/src/stream.h
+++ b/src/stream.h
@@ -13,7 +13,7 @@
 #include <stdint.h>
 #include <stdio.h>
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 namespace Bu
 {
@@ -53,7 +53,7 @@ namespace Bu
                  * data in a non-blocking stream.
                  *@returns The line read, not including newline character.
                  */
-                virtual Bu::FString readLine();
+                virtual Bu::String readLine();
 
                 /**
                  * Write data to the stream.
@@ -63,7 +63,7 @@ namespace Bu
                  */
                 virtual size write( const void *pBuf, size iBytes ) = 0;
 
-                virtual size write( const Bu::FString &sBuf );
+                virtual size write( const Bu::String &sBuf );
 
                 /**
                  * Get the current position in the stream.
@@ -185,7 +185,7 @@ namespace Bu
                  * it may give you an ip address, etc.  If it isn't supported, an empty
                  * string may be returned.
                  */
-                virtual Bu::FString getLocation() const = 0;
+                virtual Bu::String getLocation() const = 0;
 
         private:
 
diff --git a/src/streamstack.cpp b/src/streamstack.cpp
index 011c721..f400364 100644
--- a/src/streamstack.cpp
+++ b/src/streamstack.cpp
@@ -86,7 +86,7 @@ size_t Bu::StreamStack::write( const void *pBuf, size_t nBytes )
         return lFilts.first()->write( pBuf, nBytes );
 }
 
-size_t Bu::StreamStack::write( const Bu::FString &sBuf )
+size_t Bu::StreamStack::write( const Bu::String &sBuf )
 {
         checkStack();
 
diff --git a/src/streamstack.h b/src/streamstack.h
index f40a760..2554bd2 100644
--- a/src/streamstack.h
+++ b/src/streamstack.h
@@ -106,7 +106,7 @@ namespace Bu
                 virtual size_t read( void *pBuf, size_t nBytes );
                 virtual size_t write( const void *pBuf, size_t nBytes );
 
-                virtual size_t write( const Bu::FString &sBuf );
+                virtual size_t write( const Bu::String &sBuf );
                 virtual long tell();
                 virtual void seek( long offset );
                 virtual void setPos( long pos );
diff --git a/src/fstring.cpp b/src/string.cpp
index a3e0cb1..3f895dc 100644
--- a/src/fstring.cpp
+++ b/src/string.cpp
@@ -8,12 +8,12 @@
 #define BU_TRACE
 #include "bu/trace.h"
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/hash.h"
 
-template class Bu::FBasicString<char>;
+template class Bu::BasicString<char>;
 
-template<> uint32_t Bu::__calcHashCode<Bu::FString>( const Bu::FString &k )
+template<> uint32_t Bu::__calcHashCode<Bu::String>( const Bu::String &k )
 {
         long j, sz = k.getSize();
         const char *s = k.getStr();
@@ -27,18 +27,18 @@ template<> uint32_t Bu::__calcHashCode<Bu::FString>( const Bu::FString &k )
         return nPos;
 }
 
-template<> bool Bu::__cmpHashKeys<Bu::FString>(
-                const Bu::FString &a, const Bu::FString &b )
+template<> bool Bu::__cmpHashKeys<Bu::String>(
+                const Bu::String &a, const Bu::String &b )
 {
         return a == b;
 }
 
-template<> void Bu::__tracer_format<Bu::FString>( const Bu::FString &v )
+template<> void Bu::__tracer_format<Bu::String>( const Bu::String &v )
 {
         printf("(%ld)\"%s\"", v.getSize(), v.getStr() );
 }
 
-bool &Bu::operator<<( bool &dst, const Bu::FString &sIn )
+bool &Bu::operator<<( bool &dst, const Bu::String &sIn )
 {
         if( sIn == "true" || sIn == "yes" || sIn == "t" )
                 dst = true;
@@ -48,79 +48,79 @@ bool &Bu::operator<<( bool &dst, const Bu::FString &sIn )
         return dst;
 }
 
-uint8_t &Bu::operator<<( uint8_t &dst, const Bu::FString &sIn )
+uint8_t &Bu::operator<<( uint8_t &dst, const Bu::String &sIn )
 {
         sscanf( sIn.getStr(), "%hhu", &dst );
         return dst;
 }
 
-int8_t &Bu::operator<<( int8_t &dst, const Bu::FString &sIn )
+int8_t &Bu::operator<<( int8_t &dst, const Bu::String &sIn )
 {
         sscanf( sIn.getStr(), "%hhd", &dst );
         return dst;
 }
 
-char &Bu::operator<<( char &dst, const Bu::FString &sIn )
+char &Bu::operator<<( char &dst, const Bu::String &sIn )
 {
         sscanf( sIn.getStr(), "%hhd", &dst );
         return dst;
 }
 
-uint16_t &Bu::operator<<( uint16_t &dst, const Bu::FString &sIn )
+uint16_t &Bu::operator<<( uint16_t &dst, const Bu::String &sIn )
 {
         sscanf( sIn.getStr(), "%hu", &dst );
         return dst;
 }
 
-int16_t &Bu::operator<<( int16_t &dst, const Bu::FString &sIn )
+int16_t &Bu::operator<<( int16_t &dst, const Bu::String &sIn )
 {
         sscanf( sIn.getStr(), "%hd", &dst );
         return dst;
 }
 
-uint32_t &Bu::operator<<( uint32_t &dst, const Bu::FString &sIn )
+uint32_t &Bu::operator<<( uint32_t &dst, const Bu::String &sIn )
 {
         sscanf( sIn.getStr(), "%u", &dst );
         return dst;
 }
 
-int32_t &Bu::operator<<( int32_t &dst, const Bu::FString &sIn )
+int32_t &Bu::operator<<( int32_t &dst, const Bu::String &sIn )
 {
         sscanf( sIn.getStr(), "%d", &dst );
         return dst;
 }
 
-uint64_t &Bu::operator<<( uint64_t &dst, const Bu::FString &sIn )
+uint64_t &Bu::operator<<( uint64_t &dst, const Bu::String &sIn )
 {
         sscanf( sIn.getStr(), "%llu", &dst );
         return dst;
 }
 
-int64_t &Bu::operator<<( int64_t &dst, const Bu::FString &sIn )
+int64_t &Bu::operator<<( int64_t &dst, const Bu::String &sIn )
 {
         sscanf( sIn.getStr(), "%lld", &dst );
         return dst;
 }
 
-float &Bu::operator<<( float &dst, const Bu::FString &sIn )
+float &Bu::operator<<( float &dst, const Bu::String &sIn )
 {
         sscanf( sIn.getStr(), "%f", &dst );
         return dst;
 }
 
-double &Bu::operator<<( double &dst, const Bu::FString &sIn )
+double &Bu::operator<<( double &dst, const Bu::String &sIn )
 {
         sscanf( sIn.getStr(), "%lf", &dst );
         return dst;
 }
 
-long double &Bu::operator<<( long double &dst, const Bu::FString &sIn )
+long double &Bu::operator<<( long double &dst, const Bu::String &sIn )
 {
         sscanf( sIn.getStr(), "%Lf", &dst );
         return dst;
 }
 
-Bu::FString &Bu::operator<<( Bu::FString &dst, const Bu::FString &sIn )
+Bu::String &Bu::operator<<( Bu::String &dst, const Bu::String &sIn )
 {
         dst = sIn;
         return dst;
diff --git a/src/fbasicstring.h b/src/string.h
index 064ff16..5a0c471 100644
--- a/src/fbasicstring.h
+++ b/src/string.h
@@ -5,8 +5,8 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#ifndef BU_F_BASIC_STRING_H
-#define BU_F_BASIC_STRING_H
+#ifndef BU_STRING_H
+#define BU_STRING_H
 
 #include <stdint.h>
 #include <memory>
@@ -27,17 +27,15 @@ namespace Bu
 {
         /** @cond DEVEL */
         template< typename chr >
-        struct FStringChunk
+        struct StringChunk
         {
                 long nLength;
                 chr *pData;
-                FStringChunk *pNext;
+                StringChunk *pNext;
         };
 
-#define cpy( dest, src, size ) Bu::memcpy( dest, src, size*sizeof(chr) )
-        
         template< typename chr, int nMinSize, typename chralloc,
-                typename chunkalloc> class FBasicString;
+                typename chunkalloc> class BasicString;
 
         template<typename chr>
         size_t strlen( const chr *pData )
@@ -76,24 +74,24 @@ namespace Bu
         }
 
         template<typename chr, int nMinSize, typename chralloc, typename chunkalloc>
-        struct FStringCore
+        struct StringCore
         {
-        friend class FBasicString<chr, nMinSize, chralloc, chunkalloc>;
+        friend class BasicString<chr, nMinSize, chralloc, chunkalloc>;
         friend class SharedCore<
-                FBasicString<chr, nMinSize, chralloc, chunkalloc>,
-                FStringCore<chr, nMinSize, chralloc, chunkalloc>
+                BasicString<chr, nMinSize, chralloc, chunkalloc>,
+                StringCore<chr, nMinSize, chralloc, chunkalloc>
                 >;
         private:
-                typedef struct FStringCore<chr, nMinSize, chralloc, chunkalloc> MyType;
-                typedef struct FStringChunk<chr> Chunk;
-                FStringCore() :
+                typedef struct StringCore<chr, nMinSize, chralloc, chunkalloc> MyType;
+                typedef struct StringChunk<chr> Chunk;
+                StringCore() :
                         nLength( 0 ),
                         pFirst( NULL ),
                         pLast( NULL )
                 {
                 }
 
-                FStringCore( const MyType &rSrc ) :
+                StringCore( const MyType &rSrc ) :
                         nLength( rSrc.nLength ),
                         pFirst( NULL ),
                         pLast( NULL ),
@@ -111,14 +109,14 @@ namespace Bu
                                 int iPos = 0;
                                 while( pLink != NULL )
                                 {
-                                        cpy( pFirst->pData+iPos, pLink->pData, pLink->nLength );
+                                        memcpy( pFirst->pData+iPos, pLink->pData, pLink->nLength );
                                         iPos += pLink->nLength;
                                         pLink = pLink->pNext;
                                 }
                         }
                 }
 
-                virtual ~FStringCore()
+                virtual ~StringCore()
                 {
                         clear();
                 }
@@ -172,7 +170,7 @@ namespace Bu
                         pNew->pNext = pSrc->pNext;
                         pNew->nLength = pSrc->nLength;
                         pNew->pData = aChr.allocate( pSrc->nLength+1 );
-                        cpy( pNew->pData, pSrc->pData, pSrc->nLength );
+                        memcpy( pNew->pData, pSrc->pData, pSrc->nLength );
                         pNew->pData[pNew->nLength] = (chr)0;
                         return pNew;
                 }
@@ -214,7 +212,7 @@ namespace Bu
          * internal ref-counting means that if you pass strings around between
          * functions there's almost no overhead in time or memory since a reference
          * is created and no data is actually copied.  This also means that you
-         * never need to put any FBasicString into a ref-counting container class.
+         * never need to put any BasicString into a ref-counting container class.
          *
          *@param chr (typename) Type of character (i.e. char)
          *@param nMinSize (int) Chunk size (default: 256)
@@ -223,15 +221,15 @@ namespace Bu
          */
         template< typename chr, int nMinSize=256,
                 typename chralloc=std::allocator<chr>,
-                typename chunkalloc=std::allocator<struct FStringChunk<chr> > >
-        class FBasicString : public SharedCore<
-                                                 FBasicString<chr, nMinSize, chralloc, chunkalloc>,
-                                                 FStringCore<chr, nMinSize, chralloc, chunkalloc> >
+                typename chunkalloc=std::allocator<struct StringChunk<chr> > >
+        class BasicString : public SharedCore<
+                                                 BasicString<chr, nMinSize, chralloc, chunkalloc>,
+                                                 StringCore<chr, nMinSize, chralloc, chunkalloc> >
         {
         protected:
-                typedef struct FStringChunk<chr> Chunk;
-                typedef struct FBasicString<chr, nMinSize, chralloc, chunkalloc> MyType;
-                typedef struct FStringCore<chr, nMinSize, chralloc, chunkalloc> Core;
+                typedef struct StringChunk<chr> Chunk;
+                typedef struct BasicString<chr, nMinSize, chralloc, chunkalloc> MyType;
+                typedef struct StringCore<chr, nMinSize, chralloc, chunkalloc> Core;
 
                 using SharedCore<MyType, Core >::core;
                 using SharedCore<MyType, Core >::_hardCopy;
@@ -240,7 +238,7 @@ namespace Bu
                 struct iterator;
                 typedef struct const_iterator
                 {
-                        friend class FBasicString<chr, nMinSize, chralloc, chunkalloc>;
+                        friend class BasicString<chr, nMinSize, chralloc, chunkalloc>;
                         friend struct iterator;
                 private:
                         const_iterator( Chunk *pChunk, int iPos ) :
@@ -474,7 +472,7 @@ namespace Bu
                 
                 typedef struct iterator
                 {
-                        friend class FBasicString<chr, nMinSize, chralloc, chunkalloc>;
+                        friend class BasicString<chr, nMinSize, chralloc, chunkalloc>;
                         friend struct const_iterator;
                 private:
                         iterator( Chunk *pChunk, int iPos ) :
@@ -719,52 +717,52 @@ namespace Bu
                 } iterator;
 
         public:
-                FBasicString()
+                BasicString()
                 {
                 }
 
-                FBasicString( const chr *pData )
+                BasicString( const chr *pData )
                 {
                         append( pData );
                 }
 
-                FBasicString( const chr *pData, long nLength )
+                BasicString( const chr *pData, long nLength )
                 {
                         append( pData, nLength );
                 }
 
-                FBasicString( const MyType &rSrc ) :
+                BasicString( const MyType &rSrc ) :
                         SharedCore<MyType, Core>( rSrc )
                 {
                 }
 
-                FBasicString( const MyType &rSrc, long nLength )
+                BasicString( const MyType &rSrc, long nLength )
                 {
                         append( rSrc, nLength );
                 }
                 
-                FBasicString( const MyType &rSrc, long nStart, long nLength )
+                BasicString( const MyType &rSrc, long nStart, long nLength )
                 {
                         append( rSrc, nStart, nLength );
                 }
 
-                FBasicString( long nSize )
+                BasicString( long nSize )
                 {
                         core->pFirst = core->pLast = core->newChunk( nSize );
                         core->nLength = nSize;
                 }
 
-                FBasicString( const const_iterator &s )
+                BasicString( const const_iterator &s )
                 {
                         append( s );
                 }
 
-                FBasicString( const const_iterator &s, const const_iterator &e )
+                BasicString( const const_iterator &s, const const_iterator &e )
                 {
                         append( s, e );
                 }
 
-                virtual ~FBasicString()
+                virtual ~BasicString()
                 {
                 }
 
@@ -812,7 +810,7 @@ namespace Bu
                                 int nAmnt = nMinSize - core->pLast->nLength;
                                 if( nAmnt > nLen )
                                         nAmnt = nLen;
-                                cpy(
+                                memcpy(
                                         core->pLast->pData+core->pLast->nLength,
                                         pData,
                                         nAmnt
@@ -826,7 +824,7 @@ namespace Bu
                         if( nLen > 0 )
                         {
                                 Chunk *pNew = core->newChunk( nLen );
-                                cpy( pNew->pData, pData, nLen );
+                                memcpy( pNew->pData, pData, nLen );
                                 core->appendChunk( pNew );
 //                              core->nLength += nLen;
                         }
@@ -852,8 +850,8 @@ namespace Bu
                 }
 
                 /**
-                 * Append another FString to this one.
-                 *@param sData (MyType &) The FString to append.
+                 * Append another String to this one.
+                 *@param sData (MyType &) The String to append.
                  *@todo This function can be made much faster by not using getStr()
                  */
                 void append( const MyType & sData )
@@ -862,8 +860,8 @@ namespace Bu
                 }
                 
                 /**
-                 * Append another FString to this one.
-                 *@param sData (MyType &) The FString to append.
+                 * Append another String to this one.
+                 *@param sData (MyType &) The String to append.
                  *@param nLen How much data to append.
                  *@todo This function can be made much faster by not using getStr()
                  */
@@ -873,8 +871,8 @@ namespace Bu
                 }
                 
                 /**
-                 * Append another FString to this one.
-                 *@param sData (MyType &) The FString to append.
+                 * Append another String to this one.
+                 *@param sData (MyType &) The String to append.
                  *@param nStart Start position in sData to start copying from.
                  *@param nLen How much data to append.
                  *@todo This function can be made much faster by not using getStr()
@@ -887,9 +885,9 @@ namespace Bu
                 }
                 
                 /**
-                 * Append data to this FString using the passed in iterator as a base.
+                 * Append data to this String using the passed in iterator as a base.
                  * The iterator is const, it is not changed.
-                 *@param s Iterator from any compatible FBasicString to copy data from.
+                 *@param s Iterator from any compatible BasicString to copy data from.
                  */
                 void append( const const_iterator &s )
                 {
@@ -898,7 +896,7 @@ namespace Bu
                         Chunk *pSrc = s.pChunk;
 
                         Chunk *pNew = core->newChunk( pSrc->nLength-s.iPos );
-                        cpy( pNew->pData, pSrc->pData+s.iPos, pSrc->nLength-s.iPos );
+                        memcpy( pNew->pData, pSrc->pData+s.iPos, pSrc->nLength-s.iPos );
 
                         _hardCopy();
                         core->appendChunk( pNew );
@@ -910,9 +908,9 @@ namespace Bu
                 }
 
                 /**
-                 * Append data to this FString using the passed in iterator as a base.
+                 * Append data to this String using the passed in iterator as a base.
                  * The iterator is const, it is not changed.
-                 *@param s Iterator from any compatible FBasicString to copy data from.
+                 *@param s Iterator from any compatible BasicString to copy data from.
                  */
                 void append( const iterator &s ) // I get complaints without this one
                 {
@@ -920,11 +918,11 @@ namespace Bu
                 }
 
                 /**
-                 * Append data to this FString using the passed in iterator as a base,
+                 * Append data to this String using the passed in iterator as a base,
                  * and copy data until the ending iterator is reached.  The character
                  * at the ending iterator is not copied.
                  * The iterators are const, they are not changed.
-                 *@param s Iterator from any compatible FBasicString to copy data from.
+                 *@param s Iterator from any compatible BasicString to copy data from.
                  *@param e Iterator to stop copying at.
                  */
                 void append( const const_iterator &s, const const_iterator &e )
@@ -941,7 +939,7 @@ namespace Bu
                         {
                                 // Simple case, they're the same chunk
                                 Chunk *pNew = core->newChunk( e.iPos-s.iPos );
-                                cpy( pNew->pData, s.pChunk->pData+s.iPos, e.iPos-s.iPos );
+                                memcpy( pNew->pData, s.pChunk->pData+s.iPos, e.iPos-s.iPos );
                                 core->appendChunk( pNew );
                         }
                         else
@@ -949,7 +947,7 @@ namespace Bu
                                 // A little trickier, scan the blocks...
                                 Chunk *pSrc = s.pChunk;
                                 Chunk *pNew = core->newChunk( pSrc->nLength-s.iPos );
-                                cpy( pNew->pData, pSrc->pData+s.iPos, pSrc->nLength-s.iPos );
+                                memcpy( pNew->pData, pSrc->pData+s.iPos, pSrc->nLength-s.iPos );
                                 core->appendChunk( pNew );
 
                                 while( (pSrc = pSrc->pNext) != e.pChunk )
@@ -958,14 +956,14 @@ namespace Bu
                                 }
 
                                 pNew = core->newChunk( e.iPos );
-                                cpy( pNew->pData, pSrc->pData, e.iPos );
+                                memcpy( pNew->pData, pSrc->pData, e.iPos );
                                 core->appendChunk( pNew );
                         }
                 }
                 
                 /**
-                 * Prepend another FString to this one.
-                 *@param sData (MyType &) The FString to prepend.
+                 * Prepend another String to this one.
+                 *@param sData (MyType &) The String to prepend.
                  *@todo This function can be made much faster by not using getStr()
                  */
                 void prepend( const MyType & sData )
@@ -987,7 +985,7 @@ namespace Bu
                         for( nLen = 0; pData[nLen] != (chr)0; nLen++ ) { }
                         
                         Chunk *pNew = core->newChunk( nLen );
-                        cpy( pNew->pData, pData, nLen );
+                        memcpy( pNew->pData, pData, nLen );
 
                         core->prependChunk( pNew );
                 }
@@ -1001,7 +999,7 @@ namespace Bu
                 {
                         Chunk *pNew = core->newChunk( nLen );
                         
-                        cpy( pNew->pData, pData, nLen );
+                        memcpy( pNew->pData, pData, nLen );
 
                         _hardCopy();
                         core->prependChunk( pNew );
@@ -1037,9 +1035,9 @@ namespace Bu
                                 Chunk *p1 = core->newChunk( nPos );
                                 Chunk *p2 = core->newChunk( nLen );
                                 Chunk *p3 = core->newChunk( core->nLength-nPos );
-                                cpy( p1->pData, core->pFirst->pData, nPos );
-                                cpy( p2->pData, pData, nLen );
-                                cpy( p3->pData, core->pFirst->pData+nPos, core->nLength-nPos );
+                                memcpy( p1->pData, core->pFirst->pData, nPos );
+                                memcpy( p2->pData, pData, nLen );
+                                memcpy( p3->pData, core->pFirst->pData+nPos, core->nLength-nPos );
                                 core->clear();
                                 core->appendChunk( p1 );
                                 core->appendChunk( p2 );
@@ -1063,8 +1061,8 @@ namespace Bu
                                 _hardCopy();
                                 Chunk *p1 = core->newChunk( nPos );
                                 Chunk *p3 = core->newChunk( core->nLength-nPos );
-                                cpy( p1->pData, core->pFirst->pData, nPos );
-                                cpy( p3->pData, core->pFirst->pData+nPos, core->nLength-nPos );
+                                memcpy( p1->pData, core->pFirst->pData, nPos );
+                                memcpy( p3->pData, core->pFirst->pData+nPos, core->nLength-nPos );
                                 core->clear();
                                 core->appendChunk( p1 );
                                 for( Chunk *pChnk = str.core->pFirst; pChnk;
@@ -1148,7 +1146,7 @@ namespace Bu
                         long nNewLen = (nNewSize<core->nLength)?(nNewSize):(core->nLength);
                         if( core->nLength > 0 )
                         {
-                                cpy( pNew->pData, core->pFirst->pData, nNewLen );
+                                memcpy( pNew->pData, core->pFirst->pData, nNewLen );
                                 core->aChr.deallocate( core->pFirst->pData, core->pFirst->nLength+1 );
                                 core->aChunk.deallocate( core->pFirst, 1 );
                         }
@@ -1282,8 +1280,8 @@ namespace Bu
                 }
 
                 /**
-                 * Plus equals operator for FString.
-                 *@param pData (const chr *) The data to append to your FString.
+                 * Plus equals operator for String.
+                 *@param pData (const chr *) The data to append to your String.
                  */
                 MyType &operator+=( const chr *pData )
                 {
@@ -1293,8 +1291,8 @@ namespace Bu
                 }
                 
                 /**
-                 * Plus equals operator for FString.
-                 *@param rSrc (const MyType &) The FString to append to your FString.
+                 * Plus equals operator for String.
+                 *@param rSrc (const MyType &) The String to append to your String.
                  */
                 MyType &operator+=( const MyType &rSrc )
                 {
@@ -1311,8 +1309,8 @@ namespace Bu
                 }
 
                 /**
-                 * Plus equals operator for FString.
-                 *@param cData (const chr) The character to append to your FString.
+                 * Plus equals operator for String.
+                 *@param cData (const chr) The character to append to your String.
                  */
                 MyType &operator+=( const chr cData )
                 {
@@ -1335,7 +1333,7 @@ namespace Bu
                 /**
                  * Assignment operator.
                  *@param pData (const chr *) The character array to append to your
-                 *              FString.
+                 *              String.
                  */
                 MyType &operator=( const chr *pData )
                 {
@@ -1366,8 +1364,8 @@ namespace Bu
                 }
 
                 /**
-                 * Reset your FString to this character array.
-                 *@param pData (const chr *) The character array to set your FString to.
+                 * Reset your String to this character array.
+                 *@param pData (const chr *) The character array to set your String to.
                  */
                 void set( const chr *pData )
                 {
@@ -1376,8 +1374,8 @@ namespace Bu
                 }
 
                 /**
-                 * Reset your FString to this character array.
-                 *@param pData (const chr *) The character array to set your FString to.
+                 * Reset your String to this character array.
+                 *@param pData (const chr *) The character array to set your String to.
                  *@param nSize (long) The length of the inputted character array.
                  */
                 void set( const chr *pData, long nSize )
@@ -1467,7 +1465,7 @@ namespace Bu
 
                 /**
                  * Assignment operator.
-                 *@param rSrc (const MyType &) The FString to set your FString to.
+                 *@param rSrc (const MyType &) The String to set your String to.
                  */
         /*      MyType &operator=( const MyType &rSrc )
                 {
@@ -1478,7 +1476,7 @@ namespace Bu
                 
                 /**
                  * Equals comparison operator.
-                 *@param pData (const chr *) The character array to compare your FString
+                 *@param pData (const chr *) The character array to compare your String
                  *              to.
                  */
                 bool operator==( const chr *pData ) const
@@ -1508,7 +1506,7 @@ namespace Bu
                 
                 /**
                  * Equals comparison operator.
-                 *@param pData (const MyType &) The FString to compare your FString to.
+                 *@param pData (const MyType &) The String to compare your String to.
                  */
                 bool operator==( const MyType &pData ) const
                 {
@@ -1538,7 +1536,7 @@ namespace Bu
 
                 /**
                  * Not equals comparison operator.
-                 *@param pData (const chr *) The character array to compare your FString
+                 *@param pData (const chr *) The character array to compare your String
                  *              to.
                  */
                 bool operator!=(const chr *pData ) const
@@ -1548,7 +1546,7 @@ namespace Bu
                 
                 /**
                  * Not equals comparison operator.
-                 *@param pData (const MyType &) The FString to compare your FString to.
+                 *@param pData (const MyType &) The String to compare your String to.
                  */
                 bool operator!=(const MyType &pData ) const
                 {
@@ -1939,7 +1937,7 @@ namespace Bu
                         long nNewLen = core->nLength - nAmnt;
                         flatten();
                         Chunk *pNew = core->newChunk( nNewLen );
-                        cpy( pNew->pData, core->pFirst->pData+nAmnt, nNewLen );
+                        memcpy( pNew->pData, core->pFirst->pData+nAmnt, nNewLen );
                         _hardCopy();
                         core->clear();
                         core->appendChunk( pNew );
@@ -2051,7 +2049,7 @@ namespace Bu
                         Chunk *i = core->pFirst;
                         for(;;)
                         {
-                                cpy( pos, i->pData, i->nLength );
+                                memcpy( pos, i->pData, i->nLength );
                                 pos += i->nLength;
                                 i = i->pNext;
                                 if( i == NULL )
@@ -2069,15 +2067,15 @@ namespace Bu
                 }
         };
         
-        template<class T> FBasicString<T> operator+( const T *pLeft, const FBasicString<T> &rRight )
+        template<class T> BasicString<T> operator+( const T *pLeft, const BasicString<T> &rRight )
         {
-                Bu::FBasicString<T> ret( pLeft );
+                Bu::BasicString<T> ret( pLeft );
                 ret.append( rRight );
                 return ret;
         }
 
         template<class chr, int b, class c, class d>
-        ArchiveBase &operator<<( ArchiveBase &ar, const FBasicString<chr, b, c, d> &s )
+        ArchiveBase &operator<<( ArchiveBase &ar, const BasicString<chr, b, c, d> &s )
         {
                 long n = s.getSize();
                 ar << n;
@@ -2086,7 +2084,7 @@ namespace Bu
         }
 
         template<class chr, int b, class c, class d>
-        ArchiveBase &operator>>( ArchiveBase &ar, FBasicString<chr, b, c, d> &s )
+        ArchiveBase &operator>>( ArchiveBase &ar, BasicString<chr, b, c, d> &s )
         {
                 long n;
                 ar >> n;
@@ -2094,8 +2092,38 @@ namespace Bu
                 ar.read( s.getStr(), n );
                 return ar;
         }
-}
 
-#undef cpy
+        typedef BasicString<char> String;
+
+        template<typename T>
+        uint32_t __calcHashCode( const T &k );
+
+        template<typename T>
+        bool __cmpHashKeys( const T &a, const T &b );
+
+        template<> uint32_t __calcHashCode<String>( const String &k );
+        template<> bool __cmpHashKeys<String>(
+                const String &a, const String &b );
+        
+        template<typename t> void __tracer_format( const t &v );
+        template<> void __tracer_format<String>( const String &v );
+
+        bool &operator<<( bool &dst, const String &sIn );
+        uint8_t &operator<<( uint8_t &dst, const String &sIn );
+        int8_t &operator<<( int8_t &dst, const String &sIn );
+        char &operator<<( char &dst, const String &sIn );
+        uint16_t &operator<<( uint16_t &dst, const String &sIn );
+        int16_t &operator<<( int16_t &dst, const String &sIn );
+        uint32_t &operator<<( uint32_t &dst, const String &sIn );
+        int32_t &operator<<( int32_t &dst, const String &sIn );
+        uint64_t &operator<<( uint64_t &dst, const String &sIn );
+        int64_t &operator<<( int64_t &dst, const String &sIn );
+        float &operator<<( float &dst, const String &sIn );
+        double &operator<<( double &dst, const String &sIn );
+        long double &operator<<( long double &dst, const String &sIn );
+        Bu::String &operator<<( Bu::String &dst, const String &sIn );
+
+        typedef Bu::List<String> StringList;
+};
 
 #endif
diff --git a/src/tafcomment.cpp b/src/tafcomment.cpp
index 77b7ee4..2f0dc17 100644
--- a/src/tafcomment.cpp
+++ b/src/tafcomment.cpp
@@ -14,7 +14,7 @@ Bu::TafComment::TafComment( const Bu::TafComment &rSrc ) :
 {
 }
 
-Bu::TafComment::TafComment( const Bu::FString &sText, bool bEOL ) :
+Bu::TafComment::TafComment( const Bu::String &sText, bool bEOL ) :
         TafNode( typeComment ),
         sText( sText ),
         bEOL( bEOL )
@@ -25,7 +25,7 @@ Bu::TafComment::~TafComment()
 {
 }
 
-const Bu::FString &Bu::TafComment::getText() const
+const Bu::String &Bu::TafComment::getText() const
 {
         return sText;
 }
diff --git a/src/tafcomment.h b/src/tafcomment.h
index 5b51f99..942beb3 100644
--- a/src/tafcomment.h
+++ b/src/tafcomment.h
@@ -21,14 +21,14 @@ namespace Bu
         {
         public:
                 TafComment( const Bu::TafComment &rSrc );
-                TafComment( const Bu::FString &sText, bool bEOL=false );
+                TafComment( const Bu::String &sText, bool bEOL=false );
                 virtual ~TafComment();
 
-                const Bu::FString &getText() const;
+                const Bu::String &getText() const;
                 bool isEOLStyle() const;
 
         private:
-                Bu::FString sText;
+                Bu::String sText;
                 bool bEOL;
         };
 }
diff --git a/src/tafgroup.cpp b/src/tafgroup.cpp
index c3f5b1e..42f4610 100644
--- a/src/tafgroup.cpp
+++ b/src/tafgroup.cpp
@@ -32,7 +32,7 @@ Bu::TafGroup::TafGroup( const TafGroup &rSrc ) :
         }
 }
 
-Bu::TafGroup::TafGroup( const Bu::FString &sName ) :
+Bu::TafGroup::TafGroup( const Bu::String &sName ) :
         TafNode( typeGroup ),
         sName( sName )
 {
@@ -46,12 +46,12 @@ Bu::TafGroup::~TafGroup()
         }
 }
 
-const Bu::FString &Bu::TafGroup::getName() const
+const Bu::String &Bu::TafGroup::getName() const
 {
         return sName;
 }
 
-void Bu::TafGroup::setName( const Bu::FString &sName )
+void Bu::TafGroup::setName( const Bu::String &sName )
 {
         this->sName = sName;
 }
@@ -102,23 +102,23 @@ Bu::TafComment *Bu::TafGroup::addChild( TafComment *pNode )
         return pNode;
 }
 
-Bu::TafGroup *Bu::TafGroup::addGroup( const Bu::FString &sName )
+Bu::TafGroup *Bu::TafGroup::addGroup( const Bu::String &sName )
 {
         return addChild( new TafGroup( sName ) );
 }
 
 Bu::TafProperty *Bu::TafGroup::addProperty(
-        const Bu::FString &sName, const Bu::FString &sValue )
+        const Bu::String &sName, const Bu::String &sValue )
 {
         return addChild( new TafProperty( sName, sValue ) );
 }
 
-bool Bu::TafGroup::hasChild( const Bu::FString &sName ) const
+bool Bu::TafGroup::hasChild( const Bu::String &sName ) const
 {
         return hChildren.has( sName );
 }
 
-const Bu::TafGroup::GroupList &Bu::TafGroup::getChildren( const Bu::FString &sName ) const
+const Bu::TafGroup::GroupList &Bu::TafGroup::getChildren( const Bu::String &sName ) const
 {
         try {
                 return hChildren.get( sName );
@@ -134,7 +134,7 @@ const Bu::TafGroup::NodeList &Bu::TafGroup::getChildren() const
         return lChildren;
 }
 
-const Bu::TafGroup *Bu::TafGroup::getChild( const Bu::FString &sName ) const
+const Bu::TafGroup *Bu::TafGroup::getChild( const Bu::String &sName ) const
 {
         try {
                 return hChildren.get( sName ).first();
@@ -145,12 +145,12 @@ const Bu::TafGroup *Bu::TafGroup::getChild( const Bu::FString &sName ) const
         }
 }
 
-bool Bu::TafGroup::hasProperty( const Bu::FString &sName ) const
+bool Bu::TafGroup::hasProperty( const Bu::String &sName ) const
 {
         return hProp.has( sName );
 }
 
-const Bu::TafGroup::PropList &Bu::TafGroup::getProperties( const Bu::FString &sName ) const
+const Bu::TafGroup::PropList &Bu::TafGroup::getProperties( const Bu::String &sName ) const
 {
         try {
                 return hProp.get( sName );
@@ -161,7 +161,7 @@ const Bu::TafGroup::PropList &Bu::TafGroup::getProperties( const Bu::FString &sN
         }
 }
 
-const Bu::FString &Bu::TafGroup::getProperty( const Bu::FString &sName ) const
+const Bu::String &Bu::TafGroup::getProperty( const Bu::String &sName ) const
 {
         try {
                 return hProp.get( sName ).first();
@@ -172,8 +172,8 @@ const Bu::FString &Bu::TafGroup::getProperty( const Bu::FString &sName ) const
         }       
 }
 
-const Bu::FString &Bu::TafGroup::getProperty( const Bu::FString &sName,
-        const Bu::FString &sDef ) const
+const Bu::String &Bu::TafGroup::getProperty( const Bu::String &sName,
+        const Bu::String &sDef ) const
 {
         try
         {
@@ -186,7 +186,7 @@ const Bu::FString &Bu::TafGroup::getProperty( const Bu::FString &sName,
 }
 
 const Bu::TafGroup *Bu::TafGroup::getChildByPath(
-                const Bu::FString &sPath ) const
+                const Bu::String &sPath ) const
 {
         return getChildByPath( sPath.split('/') );
 }
@@ -203,12 +203,12 @@ const Bu::TafGroup *Bu::TafGroup::getChildByPath( Bu::StrList lPath ) const
         return cur;
 }
 
-const Bu::FString &Bu::TafGroup::getByPath( const Bu::FString &sPath ) const
+const Bu::String &Bu::TafGroup::getByPath( const Bu::String &sPath ) const
 {
         return getByPath( sPath.split('/') );
 }
 
-const Bu::FString &Bu::TafGroup::getByPath( Bu::StrList lPath ) const
+const Bu::String &Bu::TafGroup::getByPath( Bu::StrList lPath ) const
 {
         const Bu::TafGroup *cur = this;
 
diff --git a/src/tafgroup.h b/src/tafgroup.h
index ed70e8c..096a32f 100644
--- a/src/tafgroup.h
+++ b/src/tafgroup.h
@@ -10,13 +10,13 @@
 
 #include <stdint.h>
 #include "bu/tafnode.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/hash.h"
 #include "bu/list.h"
 
 namespace Bu
 {
-        typedef Bu::List<Bu::FString> StrList;
+        typedef Bu::List<Bu::String> StrList;
         class TafProperty;
         class TafComment;
         /**
@@ -26,42 +26,42 @@ namespace Bu
         class TafGroup : public TafNode
         {
         public:
-                typedef Bu::List<Bu::FString> PropList;
-                typedef Bu::Hash<Bu::FString, PropList> PropHash;
+                typedef Bu::List<Bu::String> PropList;
+                typedef Bu::Hash<Bu::String, PropList> PropHash;
                 typedef Bu::List<class Bu::TafGroup *> GroupList;
-                typedef Bu::Hash<Bu::FString, GroupList> GroupHash;
+                typedef Bu::Hash<Bu::String, GroupList> GroupHash;
                 typedef Bu::List<class Bu::TafNode *> NodeList;
 
                 TafGroup( const TafGroup &rSrc );
-                TafGroup( const Bu::FString &sName );
+                TafGroup( const Bu::String &sName );
                 virtual ~TafGroup();
 
-                const Bu::FString &getName() const;
-                void setName( const Bu::FString &sName );
+                const Bu::String &getName() const;
+                void setName( const Bu::String &sName );
 
-                bool hasProperty( const Bu::FString &sName ) const;
-                const Bu::FString &getProperty( const Bu::FString &sName ) const;
-                const Bu::FString &getProperty( const Bu::FString &sName,
-                        const Bu::FString &sDef ) const;
-                const PropList &getProperties( const Bu::FString &sName ) const;
-                bool hasChild( const Bu::FString &sName ) const;
-                const TafGroup *getChild( const Bu::FString &sName ) const;
-                const GroupList &getChildren( const Bu::FString &sName ) const;
+                bool hasProperty( const Bu::String &sName ) const;
+                const Bu::String &getProperty( const Bu::String &sName ) const;
+                const Bu::String &getProperty( const Bu::String &sName,
+                        const Bu::String &sDef ) const;
+                const PropList &getProperties( const Bu::String &sName ) const;
+                bool hasChild( const Bu::String &sName ) const;
+                const TafGroup *getChild( const Bu::String &sName ) const;
+                const GroupList &getChildren( const Bu::String &sName ) const;
                 TafNode *addChild( TafNode *pNode );
                 TafGroup *addChild( TafGroup *pNode );
                 TafProperty *addChild( TafProperty *pNode );
                 TafComment *addChild( TafComment *pNode );
-                TafGroup *addGroup( const Bu::FString &sName );
+                TafGroup *addGroup( const Bu::String &sName );
                 TafProperty *addProperty(
-                        const Bu::FString &sName, const Bu::FString &sValue );
+                        const Bu::String &sName, const Bu::String &sValue );
                 const NodeList &getChildren() const;
-                const TafGroup *getChildByPath( const Bu::FString &sPath ) const;
+                const TafGroup *getChildByPath( const Bu::String &sPath ) const;
                 const TafGroup *getChildByPath( StrList lPath ) const;
-                const Bu::FString &getByPath( const Bu::FString &sPath ) const;
-                const Bu::FString &getByPath( StrList lPath ) const;
+                const Bu::String &getByPath( const Bu::String &sPath ) const;
+                const Bu::String &getByPath( StrList lPath ) const;
 
         private:
-                Bu::FString sName;
+                Bu::String sName;
                 PropHash hProp;
                 GroupHash hChildren;
                 NodeList lChildren;
diff --git a/src/tafnode.h b/src/tafnode.h
index a535f65..6c7123d 100644
--- a/src/tafnode.h
+++ b/src/tafnode.h
@@ -9,7 +9,7 @@
 #define BU_TAF_NODE_H
 
 #include <stdint.h>
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/hash.h"
 #include "bu/exceptionbase.h"
 
diff --git a/src/tafproperty.cpp b/src/tafproperty.cpp
index c847344..96f8501 100644
--- a/src/tafproperty.cpp
+++ b/src/tafproperty.cpp
@@ -14,7 +14,7 @@ Bu::TafProperty::TafProperty( const Bu::TafProperty &rSrc ) :
 {
 }
 
-Bu::TafProperty::TafProperty( const Bu::FString &sName, const Bu::FString &sValue ) :
+Bu::TafProperty::TafProperty( const Bu::String &sName, const Bu::String &sValue ) :
         TafNode( typeProperty ),
         sName( sName ),
         sValue( sValue )
@@ -25,12 +25,12 @@ Bu::TafProperty::~TafProperty()
 {
 }
 
-const Bu::FString &Bu::TafProperty::getName() const
+const Bu::String &Bu::TafProperty::getName() const
 {
         return sName;
 }
 
-const Bu::FString &Bu::TafProperty::getValue() const
+const Bu::String &Bu::TafProperty::getValue() const
 {
         return sValue;
 }
diff --git a/src/tafproperty.h b/src/tafproperty.h
index 62cc517..10a1c1a 100644
--- a/src/tafproperty.h
+++ b/src/tafproperty.h
@@ -21,15 +21,15 @@ namespace Bu
         {
         public:
                 TafProperty( const Bu::TafProperty &rSrc );
-                TafProperty( const Bu::FString &sName, const Bu::FString &sValue );
+                TafProperty( const Bu::String &sName, const Bu::String &sValue );
                 virtual ~TafProperty();
 
-                const Bu::FString &getName() const;
-                const Bu::FString &getValue() const;
+                const Bu::String &getName() const;
+                const Bu::String &getValue() const;
 
         private:
-                Bu::FString sName;
-                Bu::FString sValue;
+                Bu::String sName;
+                Bu::String sValue;
         };
 }
 
diff --git a/src/tafreader.cpp b/src/tafreader.cpp
index ca06daf..f409170 100644
--- a/src/tafreader.cpp
+++ b/src/tafreader.cpp
@@ -6,7 +6,7 @@
  */
 
 #include "bu/taf.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/stream.h"
 
 #include <stdlib.h>
@@ -34,7 +34,7 @@ Bu::TafGroup *Bu::TafReader::readGroup()
                 throw TafException("%d:%d: Expected '{' got '%c'.", iLine, iCol, c );
         next();
         ws();
-        FString sName = readStr();
+        String sName = readStr();
         TafGroup *pGroup = new TafGroup( sName );
         try
         {
@@ -88,7 +88,7 @@ void Bu::TafReader::groupContent( Bu::TafGroup *pGroup )
 
 Bu::TafProperty *Bu::TafReader::readProperty()
 {
-        FString sName = readStr();
+        String sName = readStr();
         ws();
         if( c != '=' )
         {
@@ -96,14 +96,14 @@ Bu::TafProperty *Bu::TafReader::readProperty()
                 return new Bu::TafProperty( "", sName );
         }
         next();
-        FString sValue = readStr();
+        String sValue = readStr();
         return new Bu::TafProperty( sName, sValue );
         //printf("  %s = %s\n", sName.getStr(), sValue.getStr() );
 }
 
 Bu::TafComment *Bu::TafReader::readComment( bool bEOL )
 {
-        FString sCmnt;
+        String sCmnt;
         next();
         if( bEOL )
         {
@@ -140,10 +140,10 @@ Bu::TafComment *Bu::TafReader::readComment( bool bEOL )
         return new TafComment( sCmnt, bEOL );
 }
 
-Bu::FString Bu::TafReader::readStr()
+Bu::String Bu::TafReader::readStr()
 {
         ws();
-        FString s;
+        String s;
         if( c == '"' )
         {
                 next();
diff --git a/src/tafreader.h b/src/tafreader.h
index d60f4d2..c91d1b1 100644
--- a/src/tafreader.h
+++ b/src/tafreader.h
@@ -9,7 +9,7 @@
 #define BU_TAF_READER_H
 
 #include <stdint.h>
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 namespace Bu
 {
@@ -38,7 +38,7 @@ namespace Bu
                 void ws();
                 bool isws();
                 void next();
-                Bu::FString readStr();
+                Bu::String readStr();
                 void rawread( char *c );
                 char c, la;
                 Bu::Stream &sIn;
diff --git a/src/tafwriter.cpp b/src/tafwriter.cpp
index 215cb68..78d4060 100644
--- a/src/tafwriter.cpp
+++ b/src/tafwriter.cpp
@@ -88,10 +88,10 @@ void Bu::TafWriter::writeComment( const Bu::TafComment *pComment )
         }
 }
 
-void Bu::TafWriter::writeString( const Bu::FString &str )
+void Bu::TafWriter::writeString( const Bu::String &str )
 {
         sOut.write("\"", 1 );
-        for( Bu::FString::const_iterator s = str.begin(); s != str.end(); s++ )
+        for( Bu::String::const_iterator s = str.begin(); s != str.end(); s++ )
         {
                 if( *s == '\"' )
                         sOut.write("\\\"", 2 );
diff --git a/src/tafwriter.h b/src/tafwriter.h
index 5b7bd74..2bdd291 100644
--- a/src/tafwriter.h
+++ b/src/tafwriter.h
@@ -10,7 +10,7 @@
 
 #include <stdint.h>
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 namespace Bu
 {
@@ -35,7 +35,7 @@ namespace Bu
         private:
                 void writeProperty( const Bu::TafProperty *pProp );
                 void writeComment( const Bu::TafComment *pComment );
-                void writeString( const Bu::FString &str );
+                void writeString( const Bu::String &str );
                 void ident();
                 Bu::Stream &sOut;
                 int iDepth;
diff --git a/src/tcpserversocket.cpp b/src/tcpserversocket.cpp
index 7d7f6e4..0de6593 100644
--- a/src/tcpserversocket.cpp
+++ b/src/tcpserversocket.cpp
@@ -48,7 +48,7 @@ Bu::TcpServerSocket::TcpServerSocket( int nPort, int nPoolSize ) :
         startServer( name, nPoolSize );
 }
 
-Bu::TcpServerSocket::TcpServerSocket(const FString &sAddr,int nPort, int nPoolSize) :
+Bu::TcpServerSocket::TcpServerSocket(const String &sAddr,int nPort, int nPoolSize) :
         nPort( nPort )
 {
 #ifdef WIN32
diff --git a/src/tcpserversocket.h b/src/tcpserversocket.h
index b1d7e02..b6c6f87 100644
--- a/src/tcpserversocket.h
+++ b/src/tcpserversocket.h
@@ -9,7 +9,7 @@
 #define BU_TCP_SERVER_SOCKET_H
 
 #include <stdint.h>
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/exceptionbase.h"
 
 #ifdef WIN32
@@ -38,7 +38,7 @@ namespace Bu
         {
         public:
                 TcpServerSocket( int nPort, int nPoolSize=40 );
-                TcpServerSocket( const FString &sAddr, int nPort, int nPoolSize=40 );
+                TcpServerSocket( const String &sAddr, int nPort, int nPoolSize=40 );
                 TcpServerSocket( int nSocket, bool bInit, int nPoolSize=40 );
                 TcpServerSocket( const TcpServerSocket &rSrc );
                 virtual ~TcpServerSocket();
diff --git a/src/tcpsocket.cpp b/src/tcpsocket.cpp
index 22acdf7..522a6b7 100644
--- a/src/tcpsocket.cpp
+++ b/src/tcpsocket.cpp
@@ -42,7 +42,7 @@ Bu::TcpSocket::TcpSocket( int nTcpSocket ) :
         setAddress();
 }
 
-Bu::TcpSocket::TcpSocket( const Bu::FString &sAddr, int nPort, int nTimeout,
+Bu::TcpSocket::TcpSocket( const Bu::String &sAddr, int nPort, int nTimeout,
                 bool bBlocking ) :
         nTcpSocket( 0 ),
         bActive( false ),
@@ -440,7 +440,7 @@ void Bu::TcpSocket::setAddress()
         printf("%d\n", IP_MTU );
 }
 
-Bu::FString Bu::TcpSocket::getAddress() const
+Bu::String Bu::TcpSocket::getAddress() const
 {
         return sAddress;
 }
@@ -460,7 +460,7 @@ Bu::size Bu::TcpSocket::getBlockSize() const
 
 }
 
-Bu::FString Bu::TcpSocket::getLocation() const
+Bu::String Bu::TcpSocket::getLocation() const
 {
 }
 
diff --git a/src/tcpsocket.h b/src/tcpsocket.h
index 8543ad0..0941c65 100644
--- a/src/tcpsocket.h
+++ b/src/tcpsocket.h
@@ -12,7 +12,7 @@
 
 #include "bu/config.h"
 #include "bu/stream.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/exceptionbase.h"
 
 namespace Bu
@@ -61,7 +61,7 @@ namespace Bu
         {
         public:
                 TcpSocket( int nTcpSocket );
-                TcpSocket( const FString &sAddr, int nPort, int nTimeout=30,
+                TcpSocket( const String &sAddr, int nPort, int nTimeout=30,
                                 bool bBlocking=true );
                 virtual ~TcpSocket();
                 
@@ -96,12 +96,12 @@ namespace Bu
 
                 virtual void setSize( size iSize );
 
-                Bu::FString getAddress() const;
+                Bu::String getAddress() const;
                 operator int() const;
 
                 virtual size getSize() const;
                 virtual size getBlockSize() const;
-                virtual Bu::FString getLocation() const;
+                virtual Bu::String getLocation() const;
 
         private:
                 void setAddress();
@@ -113,8 +113,8 @@ namespace Bu
 #endif
                 bool bActive;
                 bool bBlocking;
-                FString sReadBuf;
-                FString sAddress;
+                String sReadBuf;
+                String sAddress;
         };
 }
 
diff --git a/src/tests/archive.cpp b/src/tests/archive.cpp
index 08e3b17..de227b0 100644
--- a/src/tests/archive.cpp
+++ b/src/tests/archive.cpp
@@ -7,7 +7,7 @@
 
 #include "bu/archive.h"
 #include "bu/file.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 using namespace Bu;
 
@@ -16,7 +16,7 @@ int main()
         File f("test.dat", File::WriteNew );
         Archive ar( f, Archive::save );
 
-        Bu::FString s("Hello there");
+        Bu::String s("Hello there");
         ar << s;
 
         ar.setProp("hi", 45 );
diff --git a/src/tests/cache.cpp b/src/tests/cache.cpp
index 7fe660a..38a5591 100644
--- a/src/tests/cache.cpp
+++ b/src/tests/cache.cpp
@@ -14,7 +14,7 @@
 
 #include "bu/cache.h"
 #include "bu/file.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/cachecalc.h"
 
 class Bob
@@ -90,7 +90,7 @@ public:
                 writeNum("bobcache/last", cLastId );
         }
 
-        long readNum( const Bu::FString &sFile )
+        long readNum( const Bu::String &sFile )
         {
                 TRACE( sFile );
                 Bu::File f( sFile, Bu::File::Read );
@@ -99,13 +99,13 @@ public:
                 return strtol( buf, NULL, 0 );
         }
 
-        void writeNum( const Bu::FString &sFile, long num )
+        void writeNum( const Bu::String &sFile, long num )
         {
                 TRACE( sFile, num );
                 Bu::File f( sFile,
                         Bu::File::Write|Bu::File::Create|Bu::File::Truncate
                         );
-                Bu::FString s;
+                Bu::String s;
                 s.format("%d", num );
                 f.write( s );
         }
@@ -126,7 +126,7 @@ public:
         virtual Bob *load( const long &key )
         {
                 TRACE( key );
-                Bu::FString sDest;
+                Bu::String sDest;
                 sDest.format("bobcache/%d", key );
                 return  new Bob( readNum( sDest ) );
         }
@@ -134,7 +134,7 @@ public:
         virtual void unload( Bob *pObj, const long &key )
         {
                 TRACE( pObj, key );
-                Bu::FString sDest;
+                Bu::String sDest;
                 sDest.format("bobcache/%d", key );
                 writeNum( sDest, pObj->getInt() );
                 delete pObj;
@@ -144,7 +144,7 @@ public:
         {
                 TRACE( rSrc );
                 long id = ++cLastId;
-                Bu::FString sDest;
+                Bu::String sDest;
                 sDest.format("bobcache/%d", id );
                 writeNum( sDest, rSrc->getInt() );
                 return id;
@@ -153,7 +153,7 @@ public:
         virtual void destroy( Bob *pObj, const long &key )
         {
                 TRACE( pObj, key );
-                Bu::FString sDest;
+                Bu::String sDest;
                 sDest.format("bobcache/%d", key );
                 if( !access( sDest.getStr(), F_OK ) )
                         unlink( sDest.getStr() );
@@ -163,7 +163,7 @@ public:
         virtual void destroy( const long &key )
         {
                 TRACE( pObj, key );
-                Bu::FString sDest;
+                Bu::String sDest;
                 sDest.format("bobcache/%d", key );
                 if( !access( sDest.getStr(), F_OK ) )
                         unlink( sDest.getStr() );
diff --git a/src/tests/fastcgi.cpp b/src/tests/fastcgi.cpp
index a3fa675..5f7758e 100644
--- a/src/tests/fastcgi.cpp
+++ b/src/tests/fastcgi.cpp
@@ -27,10 +27,10 @@ public:
         }
 
         virtual int onRequest( const StrHash &hParams,
-                const Bu::FString &sStdIn, Bu::Stream &sStdOut,
+                const Bu::String &sStdIn, Bu::Stream &sStdOut,
                 Bu::Stream &/*sStdErr*/ )
         {
-                Bu::FString sOut("Content-Type: text/html\r\n\r\n");
+                Bu::String sOut("Content-Type: text/html\r\n\r\n");
                 sOut += "<html><body><h1>Environment:</h1><ul>";
                 for( StrHash::const_iterator i = hParams.begin(); i; i++ )
                 {
@@ -44,8 +44,8 @@ public:
                 sOut += "</li></ul>";
                 sOut += "<h1>Stdin:</h1>";
                 sOut.formatAppend("%d bytes<pre>", sStdIn.getSize() );
-                Bu::FString sL, sR;
-                for( Bu::FString::const_iterator i = sStdIn.begin();
+                Bu::String sL, sR;
+                for( Bu::String::const_iterator i = sStdIn.begin();
                         i; i++ )
                 {
                         sL.formatAppend("%02X ",
diff --git a/src/tests/fstratsptr.cpp b/src/tests/fstratsptr.cpp
index 2303d6a..fa38459 100644
--- a/src/tests/fstratsptr.cpp
+++ b/src/tests/fstratsptr.cpp
@@ -5,7 +5,7 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/atom.h"
 #include "bu/sptr.h"
 
@@ -15,8 +15,8 @@ public:
         Person(){};
         virtual ~Person(){};
 
-        Bu::Atom<Bu::FString> sFirstName;
-        Bu::Atom<Bu::FString> sLastName;
+        Bu::Atom<Bu::String> sFirstName;
+        Bu::Atom<Bu::String> sLastName;
 };
 
 typedef Bu::SPtr<Person> PersonPtr;
@@ -45,7 +45,7 @@ int main()
         Swap(one, two);
 */
 
-        Bu::Atom<Bu::FString> sOne, sTwo;
+        Bu::Atom<Bu::String> sOne, sTwo;
         sOne = "Hello";
         sTwo = sOne;
 
diff --git a/src/tests/fstrformat.cpp b/src/tests/fstrformat.cpp
index a8e9def..2f04fe9 100644
--- a/src/tests/fstrformat.cpp
+++ b/src/tests/fstrformat.cpp
@@ -5,12 +5,12 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include <stdio.h>
 
 int main()
 {
-        Bu::FString s;
+        Bu::String s;
 
         s.format("%d, %f, \'%s\'", 144, 12.5, "bob" );
 
diff --git a/src/tests/fstring.cpp b/src/tests/fstring.cpp
index c343172..acc3558 100644
--- a/src/tests/fstring.cpp
+++ b/src/tests/fstring.cpp
@@ -6,7 +6,7 @@
  */
 
 #include "bu/hash.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include <sys/time.h>
 #include <string>
 
@@ -27,9 +27,9 @@ inline double getTime()
 }
 #endif
 
-Bu::FString genThing()
+Bu::String genThing()
 {
-        Bu::FString bob;
+        Bu::String bob;
         bob.append("ab ");
         bob += "cd ";
         bob += "efg";
@@ -39,7 +39,7 @@ Bu::FString genThing()
         return bob;
 }
 
-void thing( Bu::FString str )
+void thing( Bu::String str )
 {
         printf("Hey:  %s\n", str.getStr() );
 }
@@ -49,21 +49,21 @@ void copyfunc( std::string temp )
         temp += "Hi";
 }
 
-void copyfunc( Bu::FString temp )
+void copyfunc( Bu::String temp )
 {
         temp += "Hi";
 }
 
 void doTimings()
 {
-        Bu::FString fs1, fs2;
+        Bu::String fs1, fs2;
         std::string ss1, ss2;
         double dStart, dEnd, tfs1, tfs2, tfs3, tss1, tss2, tss3;
         int nChars = 500000, nChunks=5000, nCopies=5000000, nChunkSize=1024*4;
         char *buf = new char[nChunkSize];
         memset( buf, '!', nChunkSize );
 
-        printf("Timing Bu::FString single chars...\n");
+        printf("Timing Bu::String single chars...\n");
         dStart = getTime();
         for( int j = 0; j < nChars; j++ ) fs1 += (char)('a'+(j%26));
         fs1.getStr();
@@ -77,7 +77,7 @@ void doTimings()
         dEnd = getTime();
         tss1 = dEnd-dStart;
 
-        printf("Timing Bu::FString %d char chunks...\n", nChunkSize);
+        printf("Timing Bu::String %d char chunks...\n", nChunkSize);
         dStart = getTime();
         for( int j = 0; j < nChunks; j++ ) fs2.append(buf, nChunkSize);
         fs2.getStr();
@@ -93,9 +93,9 @@ void doTimings()
 
         fs2 = "Hello there.";
         ss2 = "Hello there.";
-        printf("Timing Bu::FString copies...\n");
+        printf("Timing Bu::String copies...\n");
         dStart = getTime();
-        for( int j = 0; j < nCopies; j++ ) Bu::FString stmp = fs2;
+        for( int j = 0; j < nCopies; j++ ) Bu::String stmp = fs2;
         dEnd = getTime();
         tfs3 = dEnd-dStart;
 
@@ -107,7 +107,7 @@ void doTimings()
 
         printf(
                 "Results:       singles:        chunks:         copies:\n"
-                "Bu::FString    %10.2f/s   %10.2f/s   %10.2f/s\n"
+                "Bu::String    %10.2f/s   %10.2f/s   %10.2f/s\n"
                 "std::string    %10.2f/s   %10.2f/s   %10.2f/s\n",
                 nChars/tfs1, nChunks/tfs2, nCopies/tfs3,
                 nChars/tss1, nChunks/tss2, nCopies/tss3 );
@@ -118,16 +118,16 @@ void doTimings()
 #define pem printf("---------\n%08tX: %s\n%08tX: %s\n", (ptrdiff_t)str.getStr(), str.getStr(), (ptrdiff_t)str2.getStr(), str2.getStr() );
 int main( )
 {
-        Bu::FString fs1;
+        Bu::String fs1;
         for( int j = 0; j < 500000; j++ ) fs1 += (char)('a'+(j%26));
         return 0;
 
-        Bu::FString str("th");
+        Bu::String str("th");
 
         str.prepend("Hello ");
         str.append("ere.");
 
-        Bu::FString str2( str );
+        Bu::String str2( str );
         pem;
         str += "  What's up?";
         pem;
diff --git a/src/tests/fstrstd.cpp b/src/tests/fstrstd.cpp
index 86d7c5c..4209c65 100644
--- a/src/tests/fstrstd.cpp
+++ b/src/tests/fstrstd.cpp
@@ -6,11 +6,11 @@
  */
 
 #include <iostream>
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 int main()
 {
-        Bu::FString s("Hey there, dude.\n");
+        Bu::String s("Hey there, dude.\n");
 
 //      std::cout << s << 5;
 }
diff --git a/src/tests/hash2.cpp b/src/tests/hash2.cpp
index 4db248e..5f1dd09 100644
--- a/src/tests/hash2.cpp
+++ b/src/tests/hash2.cpp
@@ -5,12 +5,12 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#include <bu/fstring.h>
+#include <bu/string.h>
 #include <bu/hash.h>
 
 int main()
 {
-        Bu::Hash<Bu::FString, int> hCmd;
+        Bu::Hash<Bu::String, int> hCmd;
 
         hCmd.insert("help", 5 );
         hCmd.insert("exit", 5 );
diff --git a/src/tests/heap.cpp b/src/tests/heap.cpp
index 7538936..3576f25 100644
--- a/src/tests/heap.cpp
+++ b/src/tests/heap.cpp
@@ -10,7 +10,7 @@
 
 #include "bu/formatter.h"
 #include "bu/heap.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/file.h"
 
 typedef struct num
@@ -38,15 +38,15 @@ typedef struct num
         }
 } num;
 
-void printHeap( Bu::Heap<Bu::FString> &h, int j )
+void printHeap( Bu::Heap<Bu::String> &h, int j )
 {
 //      return;
-        Bu::FString sFName;
+        Bu::String sFName;
         sFName.format("graph-step-%02d.dot", j );
         Bu::File fOut( sFName, Bu::File::WriteNew );
         Bu::Formatter f( fOut );
         f << "Graph step: " << j << ", total size: " << h.getSize() << f.nl;
-        for( Bu::Heap<Bu::FString>::iterator i = h.begin(); i; i++ )
+        for( Bu::Heap<Bu::String>::iterator i = h.begin(); i; i++ )
         {
                 f << *i << f.nl;
         }
@@ -73,7 +73,7 @@ int main()
         }
         printf("\n");
 */
-        Bu::Heap<Bu::FString> hStr;
+        Bu::Heap<Bu::String> hStr;
         int j = 0;
 
         hStr.enqueue("George");
@@ -100,7 +100,7 @@ int main()
         }
         printf("\n");
 
-        Bu::List<Bu::FString> lStr;
+        Bu::List<Bu::String> lStr;
 
         lStr.insertSorted("George");
         lStr.insertSorted("George");
@@ -110,7 +110,7 @@ int main()
         lStr.insertSorted("Brianna");
         lStr.insertSorted("Kate");
         lStr.insertSorted("Soggy");
-        for( Bu::List<Bu::FString>::iterator i = lStr.begin(); i; i++ )
+        for( Bu::List<Bu::String>::iterator i = lStr.begin(); i; i++ )
         {
                 printf("\"%s\" ", (*i).getStr() );
         }
diff --git a/src/tests/listsort.cpp b/src/tests/listsort.cpp
index 60d9611..00e7268 100644
--- a/src/tests/listsort.cpp
+++ b/src/tests/listsort.cpp
@@ -7,7 +7,7 @@
 
 #include <bu/list.h>
 #include <bu/sio.h>
-#include <bu/fstring.h>
+#include <bu/string.h>
 
 using namespace Bu;
 
@@ -25,7 +25,7 @@ int main()
         il.sortI( cmp );
         */
 
-        FString a("Soggy"), b("Sam");
+        String a("Soggy"), b("Sam");
 
         if( a < b )
         {
@@ -36,7 +36,7 @@ int main()
                 sio << "Good" << sio.nl;
         }
 
-        typedef List<FString> StrList;
+        typedef List<String> StrList;
 
         StrList lNames;
 
diff --git a/src/tests/mmparse.cpp b/src/tests/mmparse.cpp
index b2c3bf5..1123d21 100644
--- a/src/tests/mmparse.cpp
+++ b/src/tests/mmparse.cpp
@@ -6,7 +6,7 @@
  */
 
 #include "bu/minimacro.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 int main()
 {
diff --git a/src/tests/optparser.cpp b/src/tests/optparser.cpp
index f5d1512..ae658df 100644
--- a/src/tests/optparser.cpp
+++ b/src/tests/optparser.cpp
@@ -72,7 +72,7 @@ public:
 
         int iBob;
         float dBob;
-        Bu::FString sVar;
+        Bu::String sVar;
 };
 
 int main( int argc, char *argv[] )
diff --git a/src/tests/sha1.cpp b/src/tests/sha1.cpp
index b1c798a..84cebe5 100644
--- a/src/tests/sha1.cpp
+++ b/src/tests/sha1.cpp
@@ -28,8 +28,8 @@ int main( int argc, char *argv[] )
                                 break;
                 }
 
-                Bu::FString sRes = m.getResult();
-                for( Bu::FString::iterator i = sRes.begin(); i; i++ )
+                Bu::String sRes = m.getResult();
+                for( Bu::String::iterator i = sRes.begin(); i; i++ )
                 {
                         sio << Fmt::hex(2,false) << (int)(unsigned char)(*i);
                 }
diff --git a/src/tests/signals.cpp b/src/tests/signals.cpp
index e53c16e..a8c8c4e 100644
--- a/src/tests/signals.cpp
+++ b/src/tests/signals.cpp
@@ -32,22 +32,22 @@ public:
                 sio << iState << ": void fnc1( " << a << " )" << sio.nl;
         }
         
-        void fnc2( int a, Bu::FString b )
+        void fnc2( int a, Bu::String b )
         {
                 sio << iState << ": void fnc2( " << a << ", \"" << b << "\" )" << sio.nl;
         }
         
-        void fnc3( int a, Bu::FString b, double c )
+        void fnc3( int a, Bu::String b, double c )
         {
                 sio << iState << ": void fnc3( " << a << ", \"" << b << "\", " << c << " )" << sio.nl;
         }
         
-        void fnc4( int a, Bu::FString b, double c, char d )
+        void fnc4( int a, Bu::String b, double c, char d )
         {
                 sio << iState << ": void fnc4( " << a << ", \"" << b << "\", " << c << ", '" << d << "' )" << sio.nl;
         }
         
-        void fnc5( int a, Bu::FString b, double c, char d, long e )
+        void fnc5( int a, Bu::String b, double c, char d, long e )
         {
                 sio << iState << ": void fnc5( " << a << ", \"" << b << "\", " << c << ", '" << d << "', " << e << " )" << sio.nl;
         }
@@ -66,22 +66,22 @@ void pfnc1( int a )
         sio <<  ": void pfnc1( " << a << " )" << sio.nl;
 }
 
-void pfnc2( int a, Bu::FString b )
+void pfnc2( int a, Bu::String b )
 {
         sio <<  ": void pfnc2( " << a << ", \"" << b << "\" )" << sio.nl;
 }
 
-void pfnc3( int a, Bu::FString b, double c )
+void pfnc3( int a, Bu::String b, double c )
 {
         sio <<  ": void pfnc3( " << a << ", \"" << b << "\", " << c << " )" << sio.nl;
 }
 
-void pfnc4( int a, Bu::FString b, double c, char d )
+void pfnc4( int a, Bu::String b, double c, char d )
 {
         sio <<  ": void pfnc4( " << a << ", \"" << b << "\", " << c << ", '" << d << "' )" << sio.nl;
 }
 
-void pfnc5( int a, Bu::FString b, double c, char d, long e )
+void pfnc5( int a, Bu::String b, double c, char d, long e )
 {
         sio <<  ": void pfnc5( " << a << ", \"" << b << "\", " << c << ", '" << d << "', " << e << " )" << sio.nl;
 }
@@ -105,22 +105,22 @@ int main()
         cb1 = slot( &pfnc1 );
         cb1( 5 );
         
-        Signal2<void, int, Bu::FString> cb2( slot( &t, &Thing::fnc2 ) );
+        Signal2<void, int, Bu::String> cb2( slot( &t, &Thing::fnc2 ) );
         cb2( 5, "Hi there" );
         cb2 = slot( &pfnc2 );
         cb2( 5, "Hi there" );
         
-        Signal3<void, int, Bu::FString, double> cb3( slot( &t, &Thing::fnc3 ) );
+        Signal3<void, int, Bu::String, double> cb3( slot( &t, &Thing::fnc3 ) );
         cb3( 5, "Hi there", 12.85 );
         cb3 = slot( &pfnc3 );
         cb3( 5, "Hi there", 12.85 );
         
-        Signal4<void, int, Bu::FString, double, char> cb4( slot( &t, &Thing::fnc4 ) );
+        Signal4<void, int, Bu::String, double, char> cb4( slot( &t, &Thing::fnc4 ) );
         cb4( 5, "Hi there", 12.85, 'z' );
         cb4 = slot( &pfnc4 );
         cb4( 5, "Hi there", 12.85, 'z' );
         
-        Signal5<void, int, Bu::FString, double, char, long> cb5( slot( &t, &Thing::fnc5 ) );
+        Signal5<void, int, Bu::String, double, char, long> cb5( slot( &t, &Thing::fnc5 ) );
         cb5( 5, "Hi there", 12.85, 'z', 849 );
         cb5 = slot( &pfnc5 );
         cb5( 5, "Hi there", 12.85, 'z', 849 );
diff --git a/src/tests/size.cpp b/src/tests/size.cpp
index a9a921d..841325d 100644
--- a/src/tests/size.cpp
+++ b/src/tests/size.cpp
@@ -6,15 +6,15 @@
  */
 
 #include "bu/hash.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 #define pSize( t ) printf("%15s: %db\n", #t, sizeof( t ) );
 
 int main()
 {
         typedef Bu::Hash<char, char> charcharHash;
-        typedef Bu::Hash<Bu::FString, Bu::FString> strstrHash;
-        pSize( Bu::FString );
+        typedef Bu::Hash<Bu::String, Bu::String> strstrHash;
+        pSize( Bu::String );
         pSize( charcharHash );
         pSize( strstrHash );
 }
diff --git a/src/tests/speed.cpp b/src/tests/speed.cpp
index c6770de..c78dded 100644
--- a/src/tests/speed.cpp
+++ b/src/tests/speed.cpp
@@ -5,7 +5,7 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include <sys/time.h>
 
 template<typename a>
@@ -50,9 +50,9 @@ void fullTest( tst t )
 
 int main()
 {
-        Bu::FString str;
+        Bu::String str;
         for( int j = 0; j < 500; j++ )
                 str.append("Hey, this is a test string.  It will be reapeated many, many times.  How's that?");
-        fullTest( tstCopy<Bu::FString>( str ) );
+        fullTest( tstCopy<Bu::String>( str ) );
 }
 
diff --git a/src/tests/streamstack.cpp b/src/tests/streamstack.cpp
index b8c48e7..ea9ec0b 100644
--- a/src/tests/streamstack.cpp
+++ b/src/tests/streamstack.cpp
@@ -24,7 +24,7 @@ public:
 
         void write()
         {
-                Bu::FString s;
+                Bu::String s;
                 time_t tNow = time( NULL );
                 s = ctime( &tNow );
                 long lSize = s.getSize()-1;
@@ -34,7 +34,7 @@ public:
 
         void read()
         {
-                Bu::FString s;
+                Bu::String s;
                 long lSize;
                 rStream.read( &lSize, sizeof(long) );
                 s.setSize( lSize );
diff --git a/src/tests/telnetsrv.cpp b/src/tests/telnetsrv.cpp
index 4504aaf..f62714a 100644
--- a/src/tests/telnetsrv.cpp
+++ b/src/tests/telnetsrv.cpp
@@ -36,7 +36,7 @@ public:
                 printf("New dim = (%dx%d)\n", iWidth, iHeight );
         }
 
-        virtual void gotLine( Bu::FString &sLine )
+        virtual void gotLine( Bu::String &sLine )
         {
                 printf("Line: \"%s\"\n", sLine.getStr() );
                 write("\n\r", 2 );
diff --git a/src/tools/bnfcompile.cpp b/src/tools/bnfcompile.cpp
index 16e75a5..b7b363c 100644
--- a/src/tools/bnfcompile.cpp
+++ b/src/tools/bnfcompile.cpp
@@ -123,7 +123,7 @@ public:
                 }
         }
 
-        virtual FString tokenToString( const Token &t )
+        virtual String tokenToString( const Token &t )
         {
                 switch( (TokenType)t.iToken )
                 {
@@ -146,7 +146,7 @@ public:
 private:
         Stream &rSrc;
         QueueBuf qbIn;
-        FString sBuf;
+        String sBuf;
 };
 
 class BnfParser
@@ -201,9 +201,9 @@ private:
                         next();
                         if( pCur->iToken == tokIdentifier )
                         {
-                                hTokens.insert( pCur->vExtra.get<Bu::FString>(), ++iLastToken );
+                                hTokens.insert( pCur->vExtra.get<Bu::String>(), ++iLastToken );
                                 sio << "Added token[" << iLastToken << "]: "
-                                        << pCur->vExtra.get<Bu::FString>() << sio.nl;
+                                        << pCur->vExtra.get<Bu::String>() << sio.nl;
                         }
                         else if( pCur->iToken == tokSemiColon )
                                 break;
@@ -214,7 +214,7 @@ private:
 
         void nonTerminal()
         {
-                Bu::FString sNtName = pCur->vExtra.get<Bu::FString>();
+                Bu::String sNtName = pCur->vExtra.get<Bu::String>();
                 Parser::NonTerminal nt;
                 p.addNonTerminal( sNtName );
                 sio.incIndent();
@@ -258,8 +258,8 @@ private:
                         {
                                 case tokIdentifier:
                                         {
-                                                const Bu::FString &sName =
-                                                        pCur->vExtra.get<Bu::FString>();
+                                                const Bu::String &sName =
+                                                        pCur->vExtra.get<Bu::String>();
                                                 if( hTokens.has( sName ) )
                                                 {
                                                         pr.append(
@@ -292,8 +292,8 @@ private:
                                                 next();
                                                 if( pCur->iToken != tokIdentifier )
                                                         tokenError("tokIdentifier");
-                                                Bu::FString sName =
-                                                        pCur->vExtra.get<Bu::FString>();
+                                                Bu::String sName =
+                                                        pCur->vExtra.get<Bu::String>();
                                                 next();
                                                 if( pCur->iToken != tokCloseSquare )
                                                         tokenError("tokCloseSquare");
@@ -317,8 +317,8 @@ private:
                                                 next();
                                                 if( pCur->iToken != tokIdentifier )
                                                         tokenError("tokIdentifier");
-                                                Bu::FString sName =
-                                                        pCur->vExtra.get<Bu::FString>();
+                                                Bu::String sName =
+                                                        pCur->vExtra.get<Bu::String>();
                                                 next();
                                                 if( pCur->iToken != tokCloseCurly )
                                                         tokenError("tokCloseCurly");
@@ -366,14 +366,14 @@ private:
                 pCur = l.nextToken();
         }
 
-        void tokenError( const FString &s )
+        void tokenError( const String &s )
         {
                 throw ExceptionBase( ("Expected " + s + " but found "
                                 + l.tokenToString( *pCur ) + ".").getStr() );
         }
 
 private:
-        typedef Bu::Hash<Bu::FString, int> TokenHash;
+        typedef Bu::Hash<Bu::String, int> TokenHash;
         TokenHash hTokens;
         BnfLexer &l;
         BnfLexer::Token *pCur;
diff --git a/src/tools/mkunit.cpp b/src/tools/mkunit.cpp
index 12ce65f..c0b7b8b 100644
--- a/src/tools/mkunit.cpp
+++ b/src/tools/mkunit.cpp
@@ -15,7 +15,7 @@ public:
         {
         }
 
-        Bu::FString sName;
+        Bu::String sName;
         bool bExpectPass;
 };
 typedef Bu::List<Test> TestList;
@@ -23,7 +23,7 @@ typedef Bu::List<Test> TestList;
 class Suite
 {
 public:
-        Bu::FString sName;
+        Bu::String sName;
         TestList lTest;
 };
 //typedef Bu::List<Suite> SuiteList;
@@ -66,7 +66,7 @@ Bu::Formatter &operator<<( Bu::Formatter &f, const Suite &s )
 class Parser
 {
 public:
-        Parser( const Bu::FString &sFile ) :
+        Parser( const Bu::String &sFile ) :
                 sIn( sFile ),
                 fIn( sFile, File::Read ),
                 bIn( fIn ),
@@ -99,10 +99,10 @@ public:
                 return cBuf;
         }
         
-        TokType nextToken( Variant &v, Bu::FString &sWsOut, int &iLineStart,
+        TokType nextToken( Variant &v, Bu::String &sWsOut, int &iLineStart,
                         int &iCharStart )
         {
-                Bu::FString sTok, sWs;
+                Bu::String sTok, sWs;
         
                 char buf;
                 try
@@ -307,7 +307,7 @@ public:
         void firstPass()
         {
                 Variant v;
-                Bu::FString sWs;
+                Bu::String sWs;
                 int iL, iC;
                 for(;;)
                 {
@@ -322,7 +322,7 @@ public:
                                                 if( nextToken( v, sWs, iL, iC ) != tokFluff )
                                                         throw Bu::ExceptionBase("%d:%d: Expected string "
                                                                 "following suite.", iL, iC );
-                                                s.sName = v.get<Bu::FString>();
+                                                s.sName = v.get<Bu::String>();
                                                 if( nextToken( v, sWs, iL, iC ) != tokChar ||
                                                         v.get<char>() != '{' )
                                                         throw Bu::ExceptionBase("%d:%d: Expected {, got "
@@ -346,7 +346,7 @@ public:
                                                                         throw Bu::ExceptionBase("%d:%d: Expected "
                                                                                 "string following test.", iL, iC );
                                                                 Test t;
-                                                                t.sName = v.get<Bu::FString>();
+                                                                t.sName = v.get<Bu::String>();
                                                                 if( nextToken( v, sWs, iL, iC ) != tokBlock )
                                                                         throw Bu::ExceptionBase("%d:%d: Expected "
                                                                                 "{...} block.",
@@ -380,7 +380,7 @@ public:
                 }
         }
 
-        void secondPass( const Bu::FString &sOut )
+        void secondPass( const Bu::String &sOut )
         {
                 File fOut( sOut, File::WriteNew );
                 Formatter f( fOut );
@@ -393,7 +393,7 @@ public:
                 iChar = 0;
                 bool bHasIncluded = false;
 
-                Bu::FString sWs;
+                Bu::String sWs;
                 Variant v;
                 int iL, iC;
                 for(;;)
@@ -408,7 +408,7 @@ public:
                                                 if( nextToken( v, sWs, iL, iC ) != tokFluff )
                                                         throw Bu::ExceptionBase("%d:%d: Expected string "
                                                                 "following suite.", iL, iC );
-                                                s.sName = v.get<Bu::FString>();
+                                                s.sName = v.get<Bu::String>();
                                                 if( nextToken( v, sWs, iL, iC ) != tokChar ||
                                                         v.get<char>() != '{' )
                                                         throw Bu::ExceptionBase("%d:%d: Expected {",
@@ -421,7 +421,7 @@ public:
                                                         bHasIncluded = true;
                                                 }
 
-                                                Bu::FString sClass = "_UnitSuite_" + s.sName;
+                                                Bu::String sClass = "_UnitSuite_" + s.sName;
                                                 f << "class " << sClass
                                                         << " : public Bu::UnitSuite" << f.nl
                                                         << "{" << f.nl << "public:" << f.nl
@@ -441,7 +441,7 @@ public:
                                         }
                                         else if( t == tokEof )
                                         {
-                                                Bu::FString sClass = "_UnitSuite_" + s.sName;
+                                                Bu::String sClass = "_UnitSuite_" + s.sName;
                                                 f << sWs << f.nl << "int main( int argc, char *argv[] )"
                                                         << f.nl << "{" << f.nl << "\treturn " << sClass
                                                         << "().run( argc, argv );" << f.nl << "}" << f.nl;
@@ -458,7 +458,7 @@ public:
                                         {
                                                 case tokFluff:
                                                         fOut.write( sWs );
-                                                        fOut.write( v.get<Bu::FString>() );
+                                                        fOut.write( v.get<Bu::String>() );
                                                         break;
 
                                                 case tokTest:
@@ -468,7 +468,7 @@ public:
                                                                         throw Bu::ExceptionBase("%d:%d: Expected "
                                                                                 "string following test.", iL, iC );
                                                                 Test t;
-                                                                t.sName = v.get<Bu::FString>();
+                                                                t.sName = v.get<Bu::String>();
                                                                 if( nextToken( v, sWs, iL, iC ) != tokBlock )
                                                                         throw Bu::ExceptionBase("%d:%d: Expected "
                                                                                 "{...} block.",
@@ -499,7 +499,7 @@ public:
                                                         fOut.write( sWs );
                                                         f << f.nl << "#line " << iL << " \"" << sIn
                                                                 << "\"" << f.nl;
-                                                        fOut.write( v.get<Bu::FString>() );
+                                                        fOut.write( v.get<Bu::String>() );
 
                                                         break;
 
@@ -521,7 +521,7 @@ public:
         }
 
 private:
-        Bu::FString sIn;
+        Bu::String sIn;
         File fIn;
         Buffer bIn;
         char cBuf;
diff --git a/src/tools/myriad.cpp b/src/tools/myriad.cpp
index b6e435d..7d7956e 100644
--- a/src/tools/myriad.cpp
+++ b/src/tools/myriad.cpp
@@ -75,9 +75,9 @@ public:
         int iBlockSize;
         int iPreallocate;
         int iStream;
-        Bu::FString sFile;
-        Bu::FString sSrc;
-        Bu::FString sDst;
+        Bu::String sFile;
+        Bu::String sSrc;
+        Bu::String sDst;
 };
 
 Bu::Formatter &operator>>( Bu::Formatter &f, Mode &e )
diff --git a/src/tools/parser.cpp b/src/tools/parser.cpp
index 7933f31..8350343 100644
--- a/src/tools/parser.cpp
+++ b/src/tools/parser.cpp
@@ -118,7 +118,7 @@ public:
                                 case '8':
                                 case '9':
                                         {
-                                                Bu::FString sTmp;
+                                                Bu::String sTmp;
                                                 sTmp += b;
                                                 qbIn.seek( 1 );
                                                 for(;;)
diff --git a/src/tools/viewcsv.cpp b/src/tools/viewcsv.cpp
index d81525e..9be1291 100644
--- a/src/tools/viewcsv.cpp
+++ b/src/tools/viewcsv.cpp
@@ -38,7 +38,7 @@ public:
                 return 0;
         }
 
-        Bu::FString sFileIn;
+        Bu::String sFileIn;
         bool bHeader;
 };
 
@@ -245,10 +245,10 @@ public:
                 setHeaderRow( !bHeaderRow );
         }
 
-        Bu::FString prompt( const Bu::FString &sPrompt )
+        Bu::String prompt( const Bu::String &sPrompt )
         {
                 int maxx, maxy;
-                Bu::FString sStr;
+                Bu::String sStr;
 
                 RegEx re( sPrompt );
 
@@ -292,7 +292,7 @@ public:
                 sysCaret.reset();
         }
 
-        void findNext( const Bu::FString &sTerm )
+        void findNext( const Bu::String &sTerm )
         {
                 RegEx re( sTerm );
 
@@ -398,7 +398,7 @@ int main( int argc, char *argv[] )
         CsvView view( doc );
         view.setHeaderRow( opt.bHeader );
 
-        Bu::FString sSearchTerm;
+        Bu::String sSearchTerm;
 
         bool bRun = true;
         do
diff --git a/src/unit/archive.unit b/src/unit/archive.unit
index a7f2640..07e5e11 100644
--- a/src/unit/archive.unit
+++ b/src/unit/archive.unit
@@ -105,7 +105,7 @@ suite Archive
                 MemBuf mb;
                 {
                         Archive ar( mb, Archive::save );
-                        FString sStr("This is a test string.");
+                        String sStr("This is a test string.");
                         List<int> lList;
                         lList.append( 10 );
                         lList.append( 20 );
@@ -118,7 +118,7 @@ suite Archive
                 mb.setPos( 0 );
                 {
                         Archive ar( mb, Archive::load );
-                        FString sStr;
+                        String sStr;
                         List<int> lList;
                         ar >> sStr;
                         ar >> lList;
@@ -138,7 +138,7 @@ suite Archive
                 MemBuf mb;
                 {
                         Archive ar( mb, Archive::save );
-                        FString sStr("This is a test string.");
+                        String sStr("This is a test string.");
                         Array<int> lArray;
                         lArray.append( 10 );
                         lArray.append( 20 );
@@ -151,7 +151,7 @@ suite Archive
                 mb.setPos( 0 );
                 {
                         Archive ar( mb, Archive::load );
-                        FString sStr;
+                        String sStr;
                         Array<int> lArray;
                         ar >> sStr;
                         ar >> lArray;
@@ -171,7 +171,7 @@ suite Archive
                 MemBuf mb;
                 {
                         Archive ar( mb, Archive::save );
-                        Array<FString> lArray;
+                        Array<String> lArray;
                         lArray.append( "10" );
                         lArray.append( "20" );
                         lArray.append( "30" );
@@ -182,10 +182,10 @@ suite Archive
                 mb.setPos( 0 );
                 {
                         Archive ar( mb, Archive::load );
-                        Array<FString> lArray;
+                        Array<String> lArray;
                         ar >> lArray;
                         unitTest( lArray.getSize() == 4 );
-                        Array<FString>::iterator i = lArray.begin();
+                        Array<String>::iterator i = lArray.begin();
                         unitTest( *i == "10" ); i++;
                         unitTest( *i == "20" ); i++;
                         unitTest( *i == "30" ); i++;
diff --git a/src/unit/array.unit b/src/unit/array.unit
index f3fdeda..4dc75d8 100644
--- a/src/unit/array.unit
+++ b/src/unit/array.unit
@@ -55,7 +55,7 @@ suite Array
 
         test copy
         {
-                typedef Bu::Hash<Bu::FString, Bu::FString> StrHash;
+                typedef Bu::Hash<Bu::String, Bu::String> StrHash;
                 typedef Bu::Array<StrHash> StrHashArray;
 
                 StrHash h1;
diff --git a/src/unit/buffer.unit b/src/unit/buffer.unit
index 8ed1ec5..2a8f846 100644
--- a/src/unit/buffer.unit
+++ b/src/unit/buffer.unit
@@ -14,12 +14,12 @@ suite Buffer
 {
         test emptyFile
         {
-                Bu::FString sTmp("empty-XXXXXX");
+                Bu::String sTmp("empty-XXXXXX");
                 Bu::File fEmpty = tempFile(sTmp);
                 Bu::Buffer buf( fEmpty );
 
                 unitTest( buf.isEos() == false );
-                Bu::FString sLine = buf.readLine();
+                Bu::String sLine = buf.readLine();
                 unitTest( sLine == "" );
                 unitTest( fEmpty.isEos() == true );
                 unitTest( buf.isEos() == true );
diff --git a/src/unit/fstring.unit b/src/unit/fstring.unit
index c6d7414..d282052 100644
--- a/src/unit/fstring.unit
+++ b/src/unit/fstring.unit
@@ -6,29 +6,29 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 #include <dirent.h>
 
-suite FString
+suite String
 {
         test compare1
         {
-                Bu::FString b("Bob");
+                Bu::String b("Bob");
                 unitTest( !(b == "Bobo") );
                 unitTest( b == "Bob" );
         }
 
         test compare2
         {
-                Bu::FString b("Bobo");
+                Bu::String b("Bobo");
                 unitTest( !(b == "Bob") );
                 unitTest( b == "Bobo" );
         }
 
         test appendSingle
         {
-                Bu::FString b;
+                Bu::String b;
                 for( char l = 'a'; l < 'g'; l++ )
                         b += l;
                 unitTest( b == "abcdef" );
@@ -37,8 +37,8 @@ suite FString
 
         test shared1
         {
-                Bu::FString a("Hey there");
-                Bu::FString b( a );
+                Bu::String a("Hey there");
+                Bu::String b( a );
                 unitTest( a.getConstStr() == b.getConstStr() );
                 b += " guy";
                 unitTest( a.getConstStr() != b.getConstStr() );
@@ -48,7 +48,7 @@ suite FString
 
         test insert
         {
-                Bu::FString a("abcd");
+                Bu::String a("abcd");
                 a.insert( 2, "-!-", 3 );
                 unitTest( a == "ab-!-cd" );
                 
@@ -67,7 +67,7 @@ suite FString
 
         test remove
         {
-                Bu::FString a("abHEYcd");
+                Bu::String a("abHEYcd");
                 a.remove( 2, 3 );
                 unitTest( a == "abcd" );
                 a.remove( 2, 5 );
@@ -79,42 +79,42 @@ suite FString
 
         test add1
         {
-                Bu::FString a("hi there");
-                Bu::FString b(", yeah!");
-                Bu::FString c = a + b;
+                Bu::String a("hi there");
+                Bu::String b(", yeah!");
+                Bu::String c = a + b;
 
                 unitTest( c == "hi there, yeah!" );
         }
 
         test add2
         {
-                Bu::FString a("hi there");
-                Bu::FString c = a + ", yeah!";
+                Bu::String a("hi there");
+                Bu::String c = a + ", yeah!";
 
                 unitTest( c == "hi there, yeah!" );
         }
 
         test add3
         {
-                Bu::FString a("hi there");
-                Bu::FString b(", yeah!");
-                Bu::FString c = a + ", Mr. Man" + b;
+                Bu::String a("hi there");
+                Bu::String b(", yeah!");
+                Bu::String c = a + ", Mr. Man" + b;
 
                 unitTest( c == "hi there, Mr. Man, yeah!" );
         }
 
         test add4
         {
-                Bu::FString b(", yeah!");
-                Bu::FString c = "hi there" + b;
+                Bu::String b(", yeah!");
+                Bu::String c = "hi there" + b;
 
                 unitTest( c == "hi there, yeah!" );
         }
 
         test add5
         {
-                Bu::FString b;
-                Bu::FString c = "sup?";
+                Bu::String b;
+                Bu::String c = "sup?";
                 b += "hey, " + c;
                 
                 unitTest( b == "hey, sup?" );
@@ -122,17 +122,17 @@ suite FString
 
         test add6
         {
-                Bu::FString a("Hello");
+                Bu::String a("Hello");
                 char b[256] = {"Dude"};
-                Bu::FString c = a + "/" + b;
+                Bu::String c = a + "/" + b;
 
                 unitTest( c == "Hello/Dude" );
         }
 
         test add7
         {
-                const Bu::FString a("hello ");
-                Bu::FString b(" how ");
+                const Bu::String a("hello ");
+                Bu::String b(" how ");
                 unitTest( a == "hello " );
                 unitTest( a + "dude" == "hello dude" );
                 unitTest( a + "dude" + b + "are you?" == "hello dude how are you?" );
@@ -140,16 +140,16 @@ suite FString
 
         test subStr1
         {
-                Bu::FString a("abcdefghijklmnop");
-                Bu::FString::iterator i = a.find('f');
-                unitTest( a.getSubStr( i, Bu::FString::iterator() ) == "fghijklmnop" );
-                Bu::FString::iterator j = i.find('l');
+                Bu::String a("abcdefghijklmnop");
+                Bu::String::iterator i = a.find('f');
+                unitTest( a.getSubStr( i, Bu::String::iterator() ) == "fghijklmnop" );
+                Bu::String::iterator j = i.find('l');
                 unitTest( a.getSubStr( i, j ) == "fghijk" );
         }
 
         test compareSub1
         {
-                Bu::FString a("just a string.");
+                Bu::String a("just a string.");
                 unitTest( a.compareSub("a ", 5, 2) == true );
                 unitTest( a.compareSub("string.aoeu", 7, 11 ) == false );
                 unitTest( a.compareSub("string.aoeu", 7, 3 ) == true );
@@ -157,17 +157,17 @@ suite FString
 
         test compareSub2
         {
-                Bu::FString a("just a string.");
-                unitTest( a.compareSub(Bu::FString("a "), 5, 2) == true );
-                unitTest( a.compareSub(Bu::FString("string.aoeu"), 7, 11 ) == false );
-                unitTest( a.compareSub(Bu::FString("string.aoeu"), 7, 3 ) == true );
+                Bu::String a("just a string.");
+                unitTest( a.compareSub(Bu::String("a "), 5, 2) == true );
+                unitTest( a.compareSub(Bu::String("string.aoeu"), 7, 11 ) == false );
+                unitTest( a.compareSub(Bu::String("string.aoeu"), 7, 3 ) == true );
         }
 
         test iterator1
         {
-                Bu::FString a("This is a test.");
-                Bu::FString b;
-                for( Bu::FString::iterator i = a.begin(); i; i++ )
+                Bu::String a("This is a test.");
+                Bu::String b;
+                for( Bu::String::iterator i = a.begin(); i; i++ )
                 {
                         b += *i;
                 }
@@ -176,10 +176,10 @@ suite FString
 
         test iterator2
         {
-                Bu::FString a("This is a test.");
-                Bu::FString b("--This is a test.");
-                Bu::FString::iterator ai = a.begin();
-                Bu::FString::iterator bi = b.begin();
+                Bu::String a("This is a test.");
+                Bu::String b("--This is a test.");
+                Bu::String::iterator ai = a.begin();
+                Bu::String::iterator bi = b.begin();
                 unitTest( ai.compare( bi ) == false );
                 unitTest( bi.compare( ai ) == false );
                 bi++; bi++;
@@ -189,10 +189,10 @@ suite FString
 
         test iterator3
         {
-                Bu::FString a("1234honour");
-                Bu::FString b("--1234ueje");
-                Bu::FString::iterator ai = a.begin();
-                Bu::FString::iterator bi = b.begin();
+                Bu::String a("1234honour");
+                Bu::String b("--1234ueje");
+                Bu::String::iterator ai = a.begin();
+                Bu::String::iterator bi = b.begin();
                 unitTest( ai.compare( bi, 4 ) == false );
                 unitTest( bi.compare( ai, 4 ) == false );
                 bi++; bi++;
@@ -205,8 +205,8 @@ suite FString
 
         test iterator4
         {
-                Bu::FString a("1234aoeu");
-                Bu::FString::iterator ai = a.begin();
+                Bu::String a("1234aoeu");
+                Bu::String::iterator ai = a.begin();
                 unitTest( ai.compare("1234") == false );
                 unitTest( ai.compare("1234aoeu") == true );
                 unitTest( ai.compare("1234aoeuee") == false );
@@ -214,8 +214,8 @@ suite FString
 
         test iterator5
         {
-                Bu::FString a("1234aoeu");
-                Bu::FString::iterator ai = a.begin();
+                Bu::String a("1234aoeu");
+                Bu::String::iterator ai = a.begin();
                 unitTest( ai.compare("1234", 4) == true );
                 unitTest( ai.compare("1234aoeu", 8) == true );
                 unitTest( ai.compare("1234aoeuee", 10) == false );
@@ -223,9 +223,9 @@ suite FString
 
         test iterator6
         {
-                Bu::FString a("just ->this part");
-                Bu::FString b;
-                Bu::FString::iterator s = a.begin();
+                Bu::String a("just ->this part");
+                Bu::String b;
+                Bu::String::iterator s = a.begin();
                 for(; s; s++ )
                 {
                         if( *s == '>' )
@@ -239,7 +239,7 @@ suite FString
 
                 b.append( s );
 
-                Bu::FString c;
+                Bu::String c;
                 c.set( b.begin() );
 
                 // This is here because the comparison operator used to cause flattening.
@@ -249,9 +249,9 @@ suite FString
 
         test iterator7
         {
-                Bu::FString a("just [this] part");
-                Bu::FString b;
-                Bu::FString::iterator s = a.begin();
+                Bu::String a("just [this] part");
+                Bu::String b;
+                Bu::String::iterator s = a.begin();
                 for(; s; s++ )
                 {
                         if( *s == '[' )
@@ -260,7 +260,7 @@ suite FString
                                 break;
                         }
                 }
-                Bu::FString::iterator e = s;
+                Bu::String::iterator e = s;
                 for(; e; e++ )
                 {
                         if( *e == ']' )
@@ -273,9 +273,9 @@ suite FString
 
                 b.append( s, e );
 
-                for( Bu::FString::iterator i = b.begin(); i;)
+                for( Bu::String::iterator i = b.begin(); i;)
                 {
-                        Bu::FString::iterator k = i;
+                        Bu::String::iterator k = i;
                         k++;
                         if( !k )
                         {
@@ -284,12 +284,12 @@ suite FString
                         }
                         i = k;
                 }
-                Bu::FString l;
+                Bu::String l;
                 l.set( b.begin() );
                 unitTest( l == "thisthisthisthi" );
-                for( Bu::FString::iterator i = b.begin(); i;)
+                for( Bu::String::iterator i = b.begin(); i;)
                 {
-                        Bu::FString::iterator k = i;
+                        Bu::String::iterator k = i;
                         k++;
                         if( !k )
                         {
@@ -304,7 +304,7 @@ suite FString
 
         test isSet1
         {
-                Bu::FString bob;
+                Bu::String bob;
 
                 unitTest( bob.isSet() == false );
                 bob = "something";
@@ -315,7 +315,7 @@ suite FString
 
         test swap1
         {
-                Bu::FString a, b;
+                Bu::String a, b;
                 a = "Goodbye";
                 b = "Hello";
                 Bu::swap( a, b );
@@ -325,7 +325,7 @@ suite FString
 
         test swap2
         {
-                Bu::FString a, b;
+                Bu::String a, b;
                 a = "Goodbye";
                 b = "Hello";
                 std::swap( a, b );
@@ -335,14 +335,14 @@ suite FString
 
         test replace1
         {
-                Bu::FString a;
+                Bu::String a;
                 a = "This is a test.";
                 unitTest( a.replace("i", "ooo") == "Thooos ooos a test." );
         }
 
         test coreDerefBug1
         {
-                Bu::FString a, b;
+                Bu::String a, b;
                 a = "bob";
                 a.setSize( 0 );
                 b = a;
diff --git a/src/unit/hash.unit b/src/unit/hash.unit
index 124b074..2c1cf6a 100644
--- a/src/unit/hash.unit
+++ b/src/unit/hash.unit
@@ -6,14 +6,14 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/hash.h"
 
 #include <stdio.h>
 
-typedef Bu::Hash<Bu::FString, int> StrIntHash;
-typedef Bu::Hash<Bu::FString, Bu::FString> StrStrHash;
-typedef Bu::Hash<int, Bu::FString> IntStrHash;
+typedef Bu::Hash<Bu::String, int> StrIntHash;
+typedef Bu::Hash<Bu::String, Bu::String> StrStrHash;
+typedef Bu::Hash<int, Bu::String> IntStrHash;
 
 suite Hash
 {
@@ -24,7 +24,7 @@ suite Hash
                 for(int i=1;i<10000;i++)
                 {
                         sprintf(buf,"%d",i);
-                        Bu::FString sTmp(buf);
+                        Bu::String sTmp(buf);
                         h[sTmp] = i;
                         unitTest( h.has(sTmp) );
                 }
diff --git a/src/unit/list.unit b/src/unit/list.unit
index 66e45b2..24346a3 100644
--- a/src/unit/list.unit
+++ b/src/unit/list.unit
@@ -6,7 +6,7 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/list.h"
 
 typedef Bu::List<int> IntList;
diff --git a/src/unit/myriad.unit b/src/unit/myriad.unit
index ad8fb5d..5ac80a0 100644
--- a/src/unit/myriad.unit
+++ b/src/unit/myriad.unit
@@ -6,7 +6,7 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/file.h"
 #include "bu/myriad.h"
 #include "bu/myriadstream.h"
@@ -56,7 +56,7 @@ Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const VerifyObject &vo )
         {
                 int iRand = random()%128;
 //              ar << iRand;
-                Bu::FString sDat( iRand );
+                Bu::String sDat( iRand );
                 for( int j = 0; j < iRand; j++ )
                         sDat[j] = (char)((uint8_t)(random()%256));
                 ar << sDat;
@@ -64,7 +64,7 @@ Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const VerifyObject &vo )
                 sum.addData( sDat.getStr(), iRand );
                 vo.iBytesWritten += 4 + iRand;
         }
-        Bu::FString sRes = sum.getResult();
+        Bu::String sRes = sum.getResult();
         ar << sRes;
         vo.iBytesWritten += 4 + sRes.getSize();
         return ar;
@@ -79,13 +79,13 @@ Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, VerifyObject &vo )
         {
                 int iRand;
 //              ar >> iRand;
-                Bu::FString sStr;
+                Bu::String sStr;
                 ar >> sStr;
                 iRand = sStr.getSize();
                 sum.addData( &iRand, 4 );
                 sum.addData( sStr.getStr(), iRand );
         }
-        Bu::FString sSum;
+        Bu::String sSum;
         ar >> sSum;
         unitTest( sSum == sum.getResult() );
         int iTooMuch;
@@ -104,7 +104,7 @@ suite Myriad
 {
         test setSize
         {
-                FString sFileName("myriad-XXXXXXX");
+                String sFileName("myriad-XXXXXXX");
 
                 File fMyriad = tempFile( sFileName );
                 Myriad m( fMyriad, 32 );
@@ -194,7 +194,7 @@ suite Myriad
 
         test stressGrow
         {
-                FString sFileName("myriad-XXXXXXX");
+                String sFileName("myriad-XXXXXXX");
 
                 File fMyriad = tempFile( sFileName );
                 Myriad m( fMyriad );
@@ -256,7 +256,7 @@ suite Myriad
         
         test stressTruncate
         {
-                FString sFileName("myriad-XXXXXXX");
+                String sFileName("myriad-XXXXXXX");
 
                 File fMyriad = tempFile( sFileName );
                 Myriad m( fMyriad );
@@ -289,7 +289,7 @@ suite Myriad
         
         test stressTruncate2
         {
-                FString sFileName("myriad-XXXXXXX");
+                String sFileName("myriad-XXXXXXX");
 
                 Array<int> aStream;
 
@@ -329,7 +329,7 @@ suite Myriad
 
         test stressArchive
         {
-                FString sFileName("myriad-XXXXXX");
+                String sFileName("myriad-XXXXXX");
                 Array<int> aStream;
                 
                 srandom( 2096 );
diff --git a/src/unit/queuebuf.unit b/src/unit/queuebuf.unit
index 29ba858..8de29e4 100644
--- a/src/unit/queuebuf.unit
+++ b/src/unit/queuebuf.unit
@@ -30,7 +30,7 @@ suite QueueBuf
                 unitTest( qb.read( buf, 7 ) == 0 );
         }
 
-        void QBUF_RANDSTR( Bu::FString &fill, unsigned int iSize )
+        void QBUF_RANDSTR( Bu::String &fill, unsigned int iSize )
         {
                 char c;
                 for( unsigned int i=0; i<iSize; ++i )
@@ -44,7 +44,7 @@ suite QueueBuf
         {
                 srandom(time(NULL));
                 Bu::QueueBuf qb;
-                Bu::FString sTmp;
+                Bu::String sTmp;
                 char buf[4096];
 
                 for( int i=0; i<200; ++i )
@@ -65,12 +65,12 @@ suite QueueBuf
                         printf("%02x",(int)(uint8_t)s[i]);
         }
 
-        void QBUF_HASH( Bu::FString &fill, const char *s, int iSize )
+        void QBUF_HASH( Bu::String &fill, const char *s, int iSize )
         {
                 Bu::Md5 hash;
                 hash.reset();
                 hash.addData( s, iSize );
-                const Bu::FString &sTmp = hash.getResult();
+                const Bu::String &sTmp = hash.getResult();
                 fill.append( sTmp.getStr(), 16 );
         }
 
@@ -78,8 +78,8 @@ suite QueueBuf
         {
                 srandom(time(NULL));
                 Bu::QueueBuf qb;
-                Bu::FString sTmp;
-                Bu::FString sTmp2;
+                Bu::String sTmp;
+                Bu::String sTmp2;
                 char buf[4096];
 
                 for( int i=0; i<200; ++i )
diff --git a/src/unit/taf.unit b/src/unit/taf.unit
index cab04d2..908e591 100644
--- a/src/unit/taf.unit
+++ b/src/unit/taf.unit
@@ -18,7 +18,7 @@ suite Taf
         test read1
         {
 #define FN_TMP ("/tmp/tmpXXXXXXXX")
-                Bu::FString sFnTmp(FN_TMP);
+                Bu::String sFnTmp(FN_TMP);
                 Bu::File fOut = Bu::File::tempFile( sFnTmp );
                 const char *data =
                         "{test: name=\"Bob\"}"
@@ -43,7 +43,7 @@ suite Taf
                 Bu::TafWriter tw( mb );
                 
                 Bu::TafGroup g("Test data");
-                Bu::FString sData( 256 );
+                Bu::String sData( 256 );
                 for( int j = 0; j < 256; j++ )
                         sData[j] = (unsigned char)j;
                 g.addChild( new Bu::TafProperty("Encoded", sData) );
@@ -87,7 +87,7 @@ suite Taf
                 Bu::TafWriter tw( mb );
 
                 Bu::TafGroup g("Test Group");
-                Bu::FString sVal;
+                Bu::String sVal;
                 g.addChild( new Bu::TafProperty("Lame", sVal) );
                 tw.writeGroup( &g );
 
diff --git a/src/unit/xml.unit b/src/unit/xml.unit
index 67216f0..b4340e8 100644
--- a/src/unit/xml.unit
+++ b/src/unit/xml.unit
@@ -6,7 +6,7 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/xmlreader.h"
 #include "bu/membuf.h"
 
@@ -14,7 +14,7 @@ suite Xml
 {
         test declaration
         {
-                Bu::FString sXml("<?xml ?> <hi />");
+                Bu::String sXml("<?xml ?> <hi />");
                 Bu::MemBuf buf( sXml );
                 Bu::XmlReader xr( buf );
         }
diff --git a/src/unitsuite.cpp b/src/unitsuite.cpp
index ce6d037..58646a0 100644
--- a/src/unitsuite.cpp
+++ b/src/unitsuite.cpp
@@ -158,14 +158,14 @@ int Bu::UnitSuite::run( int argc, char *argv[] )
         return 0;
 }
 
-Bu::File Bu::UnitSuite::tempFile( Bu::FString &sFileName )
+Bu::File Bu::UnitSuite::tempFile( Bu::String &sFileName )
 {
         Bu::File f = Bu::File::tempFile( sFileName );
         lFileCleanup.append( sFileName );
         return f;
 }
 
-void Bu::UnitSuite::add( Test fTest, const Bu::FString &sName, Expect e )
+void Bu::UnitSuite::add( Test fTest, const Bu::String &sName, Expect e )
 {
         TestInfo ti;
         ti.sName = sName;
@@ -173,7 +173,7 @@ void Bu::UnitSuite::add( Test fTest, const Bu::FString &sName, Expect e )
         long index = ti.sName.rfindIdx("::");
         if( index != -1 )
         {
-                FString tmp = sSuiteName;
+                String tmp = sSuiteName;
                 tmp += ti.sName.getStr()+index;
                 ti.sName = tmp;
         }
@@ -183,7 +183,7 @@ void Bu::UnitSuite::add( Test fTest, const Bu::FString &sName, Expect e )
                 iNameWidth = ti.sName.getSize();
 }
 
-void Bu::UnitSuite::setName( const FString &sName )
+void Bu::UnitSuite::setName( const String &sName )
 {
         sSuiteName = sName;
 }
diff --git a/src/unitsuite.h b/src/unitsuite.h
index 475ee48..6ac4f3e 100644
--- a/src/unitsuite.h
+++ b/src/unitsuite.h
@@ -10,7 +10,7 @@
 
 #include <stdint.h>
 #include "bu/list.h"
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/file.h"
 #include "bu/array.h"
 
@@ -63,7 +63,7 @@ namespace Bu
 
                 int run( int argc=0, char *argv[]=NULL );
 
-                Bu::File tempFile( Bu::FString &sFileName );
+                Bu::File tempFile( Bu::String &sFileName );
 
                 typedef void (UnitSuite::*Test)();
 
@@ -71,12 +71,12 @@ namespace Bu
                 {
                 public:
                         Failed() : str(""), bFile( false ) { }
-                        Failed( const FString &s ) : str( s ), bFile( false ) { }
-                        Failed( const FString &s, const FString &sFile, int nLine ) :
+                        Failed( const String &s ) : str( s ), bFile( false ) { }
+                        Failed( const String &s, const String &sFile, int nLine ) :
                                 str( s ), sFile( sFile ), nLine( nLine ), bFile( true ) { }
 
-                        FString str;
-                        FString sFile;
+                        String str;
+                        String sFile;
                         int nLine;
                         bool bFile;
                 };
@@ -93,8 +93,8 @@ namespace Bu
                 };
                 
         protected:
-                void add( Test fTest, const Bu::FString &sName, Expect e=expectPass );
-                void setName( const FString &sName );
+                void add( Test fTest, const Bu::String &sName, Expect e=expectPass );
+                void setName( const String &sName );
 
                 void dispProgress();
                 void setStepCount( int iSteps );
@@ -102,23 +102,23 @@ namespace Bu
                 void setProgress( int iAmnt );
 
         private:
-                int onListCases( Bu::Array<Bu::FString> aParam );
+                int onListCases( Bu::Array<Bu::String> aParam );
 
         private:
                 typedef struct TestInfo
                 {
-                        FString sName;
+                        String sName;
                         Test fTest;
                         Expect eExpect;
                 } TestInfo;
 
                 typedef Bu::List<TestInfo> TestList;
                 TestList lTests;
-                FString sSuiteName;
+                String sSuiteName;
 
                 int iOptions;
 
-                typedef Bu::List<Bu::FString> StrList;
+                typedef Bu::List<Bu::String> StrList;
                 StrList lFileCleanup;
                 int iNameWidth;
                 int iStepCount;
diff --git a/src/url.cpp b/src/url.cpp
index 1f9f563..943b855 100644
--- a/src/url.cpp
+++ b/src/url.cpp
@@ -21,7 +21,7 @@ Bu::Url::Url()
 {
 }
 
-Bu::Url::Url( const Bu::FString &sUrl )
+Bu::Url::Url( const Bu::String &sUrl )
 {
         parseUrl( sUrl );
 }
@@ -30,22 +30,22 @@ Bu::Url::~Url()
 {
 }
 
-void Bu::Url::parseUrl( const Bu::FString &sUrl )
+void Bu::Url::parseUrl( const Bu::String &sUrl )
 {
         clear();
 
-        Bu::FString::const_iterator i = sUrl.begin();
+        Bu::String::const_iterator i = sUrl.begin();
         parseProtocol( i );
         parseUserPass( i );
         parseHost( i );
         parsePath( i );
 }
 
-Bu::FString Bu::Url::decode( const Bu::FString &sStr )
+Bu::String Bu::Url::decode( const Bu::String &sStr )
 {
-        Bu::FString sRet;
+        Bu::String sRet;
         char buf[3] = {0, 0, 0};
-        for( Bu::FString::const_iterator i = sStr.begin(); i; i++ )
+        for( Bu::String::const_iterator i = sStr.begin(); i; i++ )
         {
                 if( *i == '+' )
                 {
@@ -67,10 +67,10 @@ Bu::FString Bu::Url::decode( const Bu::FString &sStr )
         return sRet;
 }
 
-Bu::FString Bu::Url::encode( const Bu::FString &sStr )
+Bu::String Bu::Url::encode( const Bu::String &sStr )
 {
-        Bu::FString sRet;
-        for( Bu::FString::const_iterator i = sStr.begin(); i; i++ )
+        Bu::String sRet;
+        for( Bu::String::const_iterator i = sStr.begin(); i; i++ )
         {
                 if( *i == ' ' )
                 {
@@ -96,17 +96,17 @@ Bu::FString Bu::Url::encode( const Bu::FString &sStr )
         return sRet;
 }
 
-void Bu::Url::parseProtocol( Bu::FString::const_iterator &i )
+void Bu::Url::parseProtocol( Bu::String::const_iterator &i )
 {
-        Bu::FString::const_iterator s = i.find("://", 3);
+        Bu::String::const_iterator s = i.find("://", 3);
         if( !s )
                 throw Bu::ExceptionBase("No :// in url");
-        Bu::FString sTmp( i, s );
+        Bu::String sTmp( i, s );
         setProtocol( sTmp );
         i = s + 3;
 }
 
-void Bu::Url::setProtocol( const Bu::FString &sNewProto, bool bAutoSetPort )
+void Bu::Url::setProtocol( const Bu::String &sNewProto, bool bAutoSetPort )
 {
         sProtocol = sNewProto;
 #ifndef WIN32
@@ -121,13 +121,13 @@ void Bu::Url::setProtocol( const Bu::FString &sNewProto, bool bAutoSetPort )
 #endif
 }
 
-void Bu::Url::parseUserPass( Bu::FString::const_iterator &i )
+void Bu::Url::parseUserPass( Bu::String::const_iterator &i )
 {
-        Bu::FString::const_iterator s = i.find('@');
+        Bu::String::const_iterator s = i.find('@');
         if( !s )
                 return;
 
-        Bu::FString::const_iterator p = i.find(':');
+        Bu::String::const_iterator p = i.find(':');
         if( p )
         {
                 sUser.set( i, p );
@@ -141,9 +141,9 @@ void Bu::Url::parseUserPass( Bu::FString::const_iterator &i )
         i = s + 1;
 }
 
-void Bu::Url::parseHost( Bu::FString::const_iterator &i )
+void Bu::Url::parseHost( Bu::String::const_iterator &i )
 {
-        Bu::FString::const_iterator s = i;
+        Bu::String::const_iterator s = i;
         for( ; s && *s != '/'; s++ )
         {
                 if( *s == ':' )
@@ -151,7 +151,7 @@ void Bu::Url::parseHost( Bu::FString::const_iterator &i )
                         sHost.set( i, s );
                         i = s + 1;
                         s = i.find('/');
-                        Bu::FString sPort( i, s );
+                        Bu::String sPort( i, s );
                         iPort = strtol( sPort.getStr(), NULL, 10 );
                         i = s;
                         return;
@@ -161,17 +161,17 @@ void Bu::Url::parseHost( Bu::FString::const_iterator &i )
         i = s;
 }
 
-void Bu::Url::parsePath( const Bu::FString &sPath )
+void Bu::Url::parsePath( const Bu::String &sPath )
 {
-        Bu::FString::const_iterator i = sPath.begin();
+        Bu::String::const_iterator i = sPath.begin();
         parsePath( i );
 }
 
-void Bu::Url::parsePath( Bu::FString::const_iterator &i )
+void Bu::Url::parsePath( Bu::String::const_iterator &i )
 {
         if( i )
         {
-                Bu::FString::const_iterator s = i.find('?');
+                Bu::String::const_iterator s = i.find('?');
                 sPath.set( i, s );
                 i = s + 1;
                 if( s )
@@ -185,17 +185,17 @@ void Bu::Url::parsePath( Bu::FString::const_iterator &i )
         }
 }
 
-void Bu::Url::parseParams( const Bu::FString &sQuery )
+void Bu::Url::parseParams( const Bu::String &sQuery )
 {
-        Bu::FString::const_iterator i = sQuery.begin();
+        Bu::String::const_iterator i = sQuery.begin();
         parseParams( i );
 }
 
-void Bu::Url::parseParams( Bu::FString::const_iterator &i )
+void Bu::Url::parseParams( Bu::String::const_iterator &i )
 {
         bool bName = true;
-        Bu::FString sName, sValue;
-        for( Bu::FString::const_iterator s = i; s; s++ )
+        Bu::String sName, sValue;
+        for( Bu::String::const_iterator s = i; s; s++ )
         {
                 if( bName )
                 {
@@ -239,7 +239,7 @@ void Bu::Url::parseParams( Bu::FString::const_iterator &i )
         }
 }
 
-void Bu::Url::addParam( const Bu::FString &n, const Bu::FString &v )
+void Bu::Url::addParam( const Bu::String &n, const Bu::String &v )
 {
         lParam.append( Param( n, v ) );
 }
@@ -254,9 +254,9 @@ void Bu::Url::clear()
         iPort.clear();
 }
 
-Bu::FString Bu::Url::getFullPath() const
+Bu::String Bu::Url::getFullPath() const
 {
-        Bu::FString sBuf = sPath;
+        Bu::String sBuf = sPath;
         if( !lParam.isEmpty() )
         {
                 for( ParamList::const_iterator i = lParam.begin(); i; i++ )
@@ -277,9 +277,9 @@ Bu::FString Bu::Url::getFullPath() const
         return sBuf;
 }
 
-Bu::FString Bu::Url::getUrl() const
+Bu::String Bu::Url::getUrl() const
 {
-        Bu::FString sBuf = sProtocol + "://" + sHost + getFullPath();
+        Bu::String sBuf = sProtocol + "://" + sHost + getFullPath();
         return sBuf;
 }
 
diff --git a/src/url.h b/src/url.h
index ea761ef..13a918e 100644
--- a/src/url.h
+++ b/src/url.h
@@ -8,7 +8,7 @@
 #ifndef BU_URL_H
 #define BU_URL_H
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/atom.h"
 
 namespace Bu
@@ -20,61 +20,61 @@ namespace Bu
                 {
                         Param() { }
                         Param( const Param &r ) : sName( r.sName ), sValue( r.sValue ) { }
-                        Param( const Bu::FString &n, const Bu::FString &v ) :
+                        Param( const Bu::String &n, const Bu::String &v ) :
                                 sName( n ), sValue( v ) { }
-                        Bu::FString sName;
-                        Bu::FString sValue;
+                        Bu::String sName;
+                        Bu::String sValue;
                 } Param;
                 typedef Bu::List<Param> ParamList;
 
         public:
                 Url();
-                Url( const Bu::FString &sUrl );
+                Url( const Bu::String &sUrl );
                 virtual ~Url();
 
-                void parseUrl( const Bu::FString &sUrl );
-                void parseParams( const Bu::FString &sQuery );
-                void parseParams( Bu::FString::const_iterator &i );
-                void parsePath( const Bu::FString &sPath );
-                void parsePath( Bu::FString::const_iterator &i );
+                void parseUrl( const Bu::String &sUrl );
+                void parseParams( const Bu::String &sQuery );
+                void parseParams( Bu::String::const_iterator &i );
+                void parsePath( const Bu::String &sPath );
+                void parsePath( Bu::String::const_iterator &i );
                 void clear();
 
-                Bu::FString getUrl() const;
-                Bu::FString getFullPath() const;
+                Bu::String getUrl() const;
+                Bu::String getFullPath() const;
 
-                const Bu::FString &getProtocol() const { return sProtocol; }
-                const Bu::FString &getUser() const { return sUser; }
-                const Bu::FString &getPass() const { return sPass; }
-                const Bu::FString &getHost() const { return sHost; }
-                const Bu::FString &getPath() const { return sPath; }
+                const Bu::String &getProtocol() const { return sProtocol; }
+                const Bu::String &getUser() const { return sUser; }
+                const Bu::String &getPass() const { return sPass; }
+                const Bu::String &getHost() const { return sHost; }
+                const Bu::String &getPath() const { return sPath; }
                 int getPort() const { return iPort; }
                 ParamList::const_iterator getParamBegin() const
                         { return lParam.begin(); }
 
-                void setProtocol( const Bu::FString &sNewHost, bool bAutoSetPort=true );
-                void setUser( const Bu::FString &s ) { sUser = s; }
-                void setPass( const Bu::FString &s ) { sPass = s; }
-                void setHost( const Bu::FString &s ) { sHost = s; }
-                void setPath( const Bu::FString &s ) { sPath = s; }
+                void setProtocol( const Bu::String &sNewHost, bool bAutoSetPort=true );
+                void setUser( const Bu::String &s ) { sUser = s; }
+                void setPass( const Bu::String &s ) { sPass = s; }
+                void setHost( const Bu::String &s ) { sHost = s; }
+                void setPath( const Bu::String &s ) { sPath = s; }
                 void setPort( int i ) { iPort = i; }
-                void addParam( const Bu::FString &n, const Bu::FString &v );
+                void addParam( const Bu::String &n, const Bu::String &v );
 
                 bool hasPort() const { return iPort.has(); }
 
-                static Bu::FString decode( const Bu::FString &sStr );
-                static Bu::FString encode( const Bu::FString &sStr );
+                static Bu::String decode( const Bu::String &sStr );
+                static Bu::String encode( const Bu::String &sStr );
 
         private: // Parsing code
-                void parseProtocol( Bu::FString::const_iterator &i );
-                void parseUserPass( Bu::FString::const_iterator &i );
-                void parseHost( Bu::FString::const_iterator &i );
+                void parseProtocol( Bu::String::const_iterator &i );
+                void parseUserPass( Bu::String::const_iterator &i );
+                void parseHost( Bu::String::const_iterator &i );
 
         private:
-                Bu::FString sProtocol;
-                Bu::FString sUser;
-                Bu::FString sPass;
-                Bu::FString sHost;
-                Bu::FString sPath;
+                Bu::String sProtocol;
+                Bu::String sUser;
+                Bu::String sPass;
+                Bu::String sHost;
+                Bu::String sPath;
                 Bu::Atom<int> iPort;
                 ParamList lParam;
 
diff --git a/src/utfstring.cpp b/src/utfstring.cpp
index ae5efaf..7ba04ec 100644
--- a/src/utfstring.cpp
+++ b/src/utfstring.cpp
@@ -1,29 +1,2 @@
 #include "bu/utfstring.h"
 
-template class Bu::FBasicString<short>;
-
-template<> uint32_t Bu::__calcHashCode<Bu::UtfString>( const Bu::UtfString &k )
-{
-        long j, sz = k.getSize()*2;
-        const char *s = (const char *)k.getStr();
-
-        long nPos = 0;
-        for( j = 0; j < sz; j++, s++ )
-        {
-                nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
-        }
-
-        return nPos;    
-}
-
-template<> bool Bu::__cmpHashKeys<Bu::UtfString>(
-                const Bu::UtfString &a, const Bu::UtfString &b )
-{
-        return a == b;
-}
-
-template<> void Bu::__tracer_format<Bu::UtfString>( const Bu::UtfString &v )
-{
-        printf("(%ld)\"%s\"", v.getSize(), (const char *)v.getStr() );
-}
-
diff --git a/src/utfstring.h b/src/utfstring.h
index bbacb74..cfbd5f0 100644
--- a/src/utfstring.h
+++ b/src/utfstring.h
@@ -1,24 +1,11 @@
 #ifndef BU_UTF_STRING_H
 #define BU_UTF_STRING_H
 
-#include "bu/fbasicstring.h"
-
 namespace Bu
 {
-        typedef FBasicString<short> UtfString;
-
-        template<typename T>
-        uint32_t __calcHashCode( const T &k );
-
-        template<typename T>
-        bool __cmpHashKeys( const T &a, const T &b );
-
-        template<> uint32_t __calcHashCode<UtfString>( const UtfString &k );
-        template<> bool __cmpHashKeys<UtfString>(
-                const UtfString &a, const UtfString &b );
-        
-        template<typename t> void __tracer_format( const t &v );
-        template<> void __tracer_format<UtfString>( const UtfString &v );
-}
+        class UtfString
+        {
+        };
+};
 
 #endif
diff --git a/src/uuid.cpp b/src/uuid.cpp
index 410cf6b..f46d2ae 100644
--- a/src/uuid.cpp
+++ b/src/uuid.cpp
@@ -25,12 +25,12 @@ Bu::Uuid::~Uuid()
 {
 }
 
-Bu::FString Bu::Uuid::toRawString()
+Bu::String Bu::Uuid::toRawString()
 {
-        return Bu::FString( (char *)data, 16 );
+        return Bu::String( (char *)data, 16 );
 }
 
-Bu::FString Bu::Uuid::toString()
+Bu::String Bu::Uuid::toString()
 {
         Bu::MemBuf mb;
         Bu::Formatter f( mb );
diff --git a/src/uuid.h b/src/uuid.h
index b9a37e9..6ce8e9c 100644
--- a/src/uuid.h
+++ b/src/uuid.h
@@ -8,7 +8,7 @@
 #ifndef BU_UUID_H
 #define BU_UUID_H
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 
 namespace Bu
 {
@@ -19,8 +19,8 @@ namespace Bu
                 Uuid( const Uuid &src );
                 virtual ~Uuid();
 
-                Bu::FString toRawString();
-                Bu::FString toString();
+                Bu::String toRawString();
+                Bu::String toString();
 
                 static Uuid gen();
                 static Uuid genV1();
diff --git a/src/variant.cpp b/src/variant.cpp
index a239e0f..a23a422 100644
--- a/src/variant.cpp
+++ b/src/variant.cpp
@@ -9,7 +9,7 @@
 
 namespace Bu
 {
-        Formatter &operator<<( Formatter &f, const FString &s );
+        Formatter &operator<<( Formatter &f, const String &s );
 };
 
 Bu::VariantTypeRoot::VariantTypeRoot()
@@ -37,7 +37,7 @@ Bu::Variant::Variant( const Variant &v ) :
 Bu::Variant::Variant( const char *t ) :
         pCore( NULL )
 {
-        set( Bu::FString( t ) );
+        set( Bu::String( t ) );
 }
 
 Bu::Variant::~Variant()
@@ -54,7 +54,7 @@ bool Bu::Variant::isSet() const
         return pCore != NULL;
 }
 
-Bu::FString Bu::Variant::toString() const
+Bu::String Bu::Variant::toString() const
 {
         if( !pCore )
                 return "***NO DATA***";
@@ -90,14 +90,14 @@ Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::Variant &v )
         return f << v.toString();
 }
 
-template<> Bu::FString Bu::VariantType<int>::toString() const
+template<> Bu::String Bu::VariantType<int>::toString() const
 {
-        Bu::FString s;
+        Bu::String s;
         s.format("%d", data );
         return s;
 }
 
-template<> Bu::FString Bu::VariantType<bool>::toString() const
+template<> Bu::String Bu::VariantType<bool>::toString() const
 {
         return data?"true":"false";
 }
diff --git a/src/variant.h b/src/variant.h
index f659ad2..80f1bb9 100644
--- a/src/variant.h
+++ b/src/variant.h
@@ -8,7 +8,7 @@
 #ifndef BU_VARIANT_H
 #define BU_VARIANT_H
 
-#include <bu/fstring.h>
+#include <bu/string.h>
 #include <typeinfo>
 #include <bu/membuf.h>
 #include <bu/formatter.h>
@@ -26,7 +26,7 @@ namespace Bu
                 VariantTypeRoot();
                 virtual ~VariantTypeRoot();
 
-                virtual Bu::FString toString() const=0;
+                virtual Bu::String toString() const=0;
                 virtual const std::type_info &getType() const=0;
                 virtual VariantTypeRoot *clone() const=0;
         };
@@ -65,7 +65,7 @@ namespace Bu
                         return data;
                 }
 
-                virtual Bu::FString toString() const
+                virtual Bu::String toString() const
                 {
                         MemBuf mb;
                         Formatter f( mb );
@@ -124,7 +124,7 @@ namespace Bu
                 virtual ~Variant();
 
                 bool isSet() const;
-                Bu::FString toString() const;
+                Bu::String toString() const;
                 const std::type_info &getType() const;
 
                 Variant &operator=( const Variant &rhs );
@@ -228,8 +228,8 @@ namespace Bu
 
         Bu::Formatter &operator<<( Bu::Formatter &f, const Variant &v );
 
-        template<> Bu::FString VariantType<int>::toString() const;
-        template<> Bu::FString VariantType<bool>::toString() const;
+        template<> Bu::String VariantType<int>::toString() const;
+        template<> Bu::String VariantType<bool>::toString() const;
 };
 
 #endif
diff --git a/src/xmlreader.h b/src/xmlreader.h
index 8533c1a..a217ac5 100644
--- a/src/xmlreader.h
+++ b/src/xmlreader.h
@@ -8,7 +8,7 @@
 #ifndef BU_XML_READER_H
 #define BU_XML_READER_H
 
-#include "bu/fstring.h"
+#include "bu/string.h"
 #include "bu/exceptionbase.h"
 
 namespace Bu
@@ -27,8 +27,8 @@ namespace Bu
                 Stream &rInput;
                 int iCurToken;
                 int iNextToken;
-                Bu::FString sBuf;
-                Bu::FString sStr;
+                Bu::String sBuf;
+                Bu::String sStr;
                 bool bIgnoreWS;
                 typedef struct StreamPos
                 {