diff --git a/src/Core/Build/Tasks/ScriptCompilerTask.cs b/src/Core/Build/Tasks/ScriptCompilerTask.cs
index ae7634a09..208044eba 100644
--- a/src/Core/Build/Tasks/ScriptCompilerTask.cs
+++ b/src/Core/Build/Tasks/ScriptCompilerTask.cs
@@ -244,8 +244,13 @@ private CompilerOptions CreateOptions(IEnumerable<ITaskItem> sourceItems, IEnume
             options.IncludeResolver = this;
 
             string scriptFilePath = GetScriptFilePath(locale, minimize, includeTests);
+            string symbolFilePath = GetSymbolFilePath();
+
             outputScriptItem = new TaskItem(scriptFilePath);
+            TaskItem outputSymbolItem = new TaskItem(symbolFilePath);
+
             options.ScriptFile = new TaskItemOutputStreamSource(outputScriptItem);
+            options.SymbolFile = new TaskItemOutputStreamSource(outputSymbolItem);
 
             return options;
         }
@@ -307,6 +312,7 @@ private void GenerateDeploymentFile() {
             try {
                 string assemblyFile = Path.GetFileName(_assembly.ItemSpec);
                 string scriptsFilePath = Path.Combine(OutputPath, Path.ChangeExtension(assemblyFile, "scripts"));
+                string symbolFilePath = Path.Combine(OutputPath, Path.ChangeExtension(assemblyFile, "symbol"));
 
                 Uri scriptsUri = new Uri(Path.GetFullPath(scriptsFilePath), UriKind.Absolute);
                 IEnumerable<string> scripts =
@@ -407,6 +413,16 @@ private string GetScriptFilePath(string locale, bool minimize, bool includeTests
             return Path.GetFullPath(Path.Combine(OutputPath, Path.ChangeExtension(scriptName, extension)));
         }
 
+        private string GetSymbolFilePath() {
+            
+            string scriptName = Path.GetFileName(_assembly.ItemSpec);
+            if (Directory.Exists(OutputPath) == false) {
+                Directory.CreateDirectory(OutputPath);
+            }
+            string extension = "symbol";
+            return Path.GetFullPath(Path.Combine(OutputPath, Path.ChangeExtension(scriptName, extension)));
+        }
+
         private ICollection<IStreamSource> GetSources(IEnumerable<ITaskItem> sourceItems) {
             if (sourceItems == null) {
                 return new TaskItemInputStreamSource[0];
@@ -428,13 +444,37 @@ private ICollection<IStreamSource> GetSources(IEnumerable<ITaskItem> sourceItems
             return sources;
         }
 
+        public enum FileTypeEnum {
+            Normal,
+            Minimized,
+            Symbol
+        }
+
+        public string GetExtension(FileTypeEnum fileType) {
+            switch (fileType) {
+                case FileTypeEnum.Minimized:
+                    return ".min.js";
+
+                case FileTypeEnum.Symbol:
+                    return ".symbol";
+
+                case FileTypeEnum.Normal:
+                default:
+                    return ".js";
+            }
+        }
+
+
         private void OnScriptFileGenerated(ITaskItem scriptItem, CompilerOptions options, bool copyReferences) {
-            Func<string, bool, string> getScriptFile = delegate(string reference, bool minimized) {
-                string scriptFile = Path.ChangeExtension(reference, minimized ? ".min.js" : ".js");
+
+            Func<string, FileTypeEnum, string> getScriptFile = delegate(string reference, FileTypeEnum fileType)
+            {
+                var extension = GetExtension(fileType);
+                string scriptFile = Path.ChangeExtension(reference, extension);
 
                 string fileName = Path.GetFileNameWithoutExtension(scriptFile);
                 if (fileName.StartsWith("mscorlib", StringComparison.OrdinalIgnoreCase)) {
-                    fileName = (minimized ? "ss.min" : "ss") + Path.GetExtension(scriptFile);
+                    fileName = (fileType == FileTypeEnum.Minimized ? "ss.min" : "ss") + Path.GetExtension(scriptFile);
                     scriptFile = Path.Combine(Path.GetDirectoryName(scriptFile), fileName);
                 }
 
@@ -491,17 +531,23 @@ private void OnScriptFileGenerated(ITaskItem scriptItem, CompilerOptions options
 
             if (copyReferences) {
                 foreach (string reference in options.References) {
-                    string scriptFile = getScriptFile(reference, /* minimized */ false);
+                    string scriptFile = getScriptFile(reference, FileTypeEnum.Normal);
                     if (scriptFile != null) {
                         string path = Path.Combine(scriptFolder, CopyReferencesPath, Path.GetFileName(scriptFile));
                         safeCopyFile(scriptFile, path);
                     }
 
-                    string minScriptFile = getScriptFile(reference, /* minimized */ true);
+                    string minScriptFile = getScriptFile(reference, FileTypeEnum.Minimized);
                     if (minScriptFile != null) {
                         string path = Path.Combine(scriptFolder, CopyReferencesPath, Path.GetFileName(minScriptFile));
                         safeCopyFile(minScriptFile, path);
                     }
+
+                    string symbolFile = getScriptFile(reference, FileTypeEnum.Symbol);
+                    if (symbolFile != null) {
+                        string path = Path.Combine(scriptFolder, CopyReferencesPath, Path.GetFileName(symbolFile));
+                        safeCopyFile(symbolFile, path);
+                    }
                 }
             }
 
@@ -570,5 +616,7 @@ public TaskItemOutputStreamSource(ITaskItem taskItem, string name)
                 : base(taskItem.ItemSpec, name) {
             }
         }
+
+        
     }
 }
diff --git a/src/Core/Compiler/Compiler.csproj b/src/Core/Compiler/Compiler.csproj
index 70475588b..617ecee78 100644
--- a/src/Core/Compiler/Compiler.csproj
+++ b/src/Core/Compiler/Compiler.csproj
@@ -50,6 +50,9 @@
     <Compile Include="..\ResXParser.cs">
       <Link>ResXParser.cs</Link>
     </Compile>
+    <Compile Include="SymbolFile\AjaxMinRenameFileGenerator.cs" />
+    <Compile Include="SymbolFile\SymbolFile.cs" />
+    <Compile Include="SymbolFile\SymbolFileGenerator.cs" />
     <Compile Include="IStreamSourceResolver.cs" />
     <Compile Include="ScriptReference.cs" />
     <Compile Include="ScriptInfo.cs" />
@@ -178,6 +181,7 @@
     <Compile Include="IStreamSource.cs" />
     <Compile Include="ScriptModel\Symbols\IntrinsicType.cs" />
     <Compile Include="ScriptModel\Symbols\GenericParameterSymbol.cs" />
+    <Compile Include="SymbolFile\SymbolFileMerger.cs" />
     <Compile Include="Utility.cs" />
     <Compile Include="CompilerOptions.cs" />
     <Compile Include="IErrorHandler.cs" />
diff --git a/src/Core/Compiler/Compiler/MetadataBuilder.cs b/src/Core/Compiler/Compiler/MetadataBuilder.cs
index d846598f0..fe7d627db 100644
--- a/src/Core/Compiler/Compiler/MetadataBuilder.cs
+++ b/src/Core/Compiler/Compiler/MetadataBuilder.cs
@@ -829,6 +829,7 @@ private void BuildType(TypeSymbol typeSymbol, UserTypeNode typeNode) {
 
             if (AttributeNode.FindAttribute(attributes, "ScriptImport") != null) {
                 ScriptReference dependency = null;
+                typeSymbol.SetScriptImported();
 
                 AttributeNode dependencyAttribute = AttributeNode.FindAttribute(attributes, "ScriptDependency");
                 if (dependencyAttribute != null) {
diff --git a/src/Core/Compiler/CompilerOptions.cs b/src/Core/Compiler/CompilerOptions.cs
index 382301d7c..447cdbbff 100644
--- a/src/Core/Compiler/CompilerOptions.cs
+++ b/src/Core/Compiler/CompilerOptions.cs
@@ -21,6 +21,7 @@ public sealed class CompilerOptions {
         private ICollection<IStreamSource> _sources;
         private ICollection<IStreamSource> _resources;
         private IStreamSource _scriptFile;
+        private IStreamSource _symbolFile;
         private IStreamSource _docCommentFile;
         private IStreamSourceResolver _includeResolver;
         private bool _includeTests;
@@ -148,6 +149,15 @@ public IStreamSource ScriptFile {
             }
         }
 
+        public IStreamSource SymbolFile {
+            get {
+                return _symbolFile;
+            }
+            set {
+                _symbolFile = value;
+            }
+        }
+
         public ICollection<IStreamSource> Sources {
             get {
                 return _sources;
diff --git a/src/Core/Compiler/Generator/ExpressionGenerator.cs b/src/Core/Compiler/Generator/ExpressionGenerator.cs
index 796d4e430..8bb906043 100644
--- a/src/Core/Compiler/Generator/ExpressionGenerator.cs
+++ b/src/Core/Compiler/Generator/ExpressionGenerator.cs
@@ -266,9 +266,11 @@ private static void GenerateDelegateExpression(ScriptGenerator generator, Member
                 }
             }
             else {
-                writer.Write("ss.bind('");
+                writer.Write("ss.bind(");
+                ExpressionGenerator.GenerateExpression(generator, symbol, expression.ObjectReference);
+                writer.Write(".");
                 writer.Write(expression.Method.GeneratedName);
-                writer.Write("', ");
+                writer.Write(", ");
                 ExpressionGenerator.GenerateExpression(generator, symbol, expression.ObjectReference);
                 writer.Write(")");
             }
diff --git a/src/Core/Compiler/ScriptCompiler.cs b/src/Core/Compiler/ScriptCompiler.cs
index 50045e229..bb9189e04 100644
--- a/src/Core/Compiler/ScriptCompiler.cs
+++ b/src/Core/Compiler/ScriptCompiler.cs
@@ -17,6 +17,7 @@
 using ScriptSharp.ResourceModel;
 using ScriptSharp.ScriptModel;
 using ScriptSharp.Validator;
+using ScriptSharp.SymbolFile;
 
 namespace ScriptSharp {
 
@@ -223,9 +224,47 @@ public bool Compile(CompilerOptions options) {
                 return false;
             }
 
+            GenerateSymbol();
+            if (_hasErrors) {
+                return false;
+            }
+
             return true;
         }
 
+        private void GenerateSymbol() {
+
+            Stream outputStream = null;
+            TextWriter outputWriter = null;
+
+            try {
+                outputStream = _options.SymbolFile.GetStream();
+                if (outputStream == null) {
+                    ((IErrorHandler)this).ReportError("Unable to write to file " + _options.SymbolFile.FullName,
+                                                      _options.SymbolFile.FullName);
+                    return;
+                }
+
+                outputWriter = new StreamWriter(outputStream);
+
+                var sfg = new SymbolFileGenerator(outputWriter);
+                sfg.Generate(_symbols);
+
+            } catch (Exception e) {
+                Debug.Fail(e.ToString());
+            } finally {
+                if (outputWriter != null) {
+                    outputWriter.Flush();
+                }
+                if (outputStream != null) {
+                    _options.SymbolFile.CloseStream(outputStream);
+                }
+            }
+
+
+
+        }
+
         private void GenerateScript() {
             Stream outputStream = null;
             TextWriter outputWriter = null;
@@ -243,9 +282,11 @@ private void GenerateScript() {
 #if DEBUG
                 if (_options.InternalTestMode) {
                     if (_testOutput != null) {
+                        outputWriter.WriteLine("/**");
                         outputWriter.Write(_testOutput);
                         outputWriter.WriteLine("Script");
                         outputWriter.WriteLine("================================================================");
+                        outputWriter.Write("**/");
                         outputWriter.WriteLine();
                         outputWriter.WriteLine();
                     }
diff --git a/src/Core/Compiler/ScriptModel/Symbols/TypeSymbol.cs b/src/Core/Compiler/ScriptModel/Symbols/TypeSymbol.cs
index 5a42280cf..899d731f0 100644
--- a/src/Core/Compiler/ScriptModel/Symbols/TypeSymbol.cs
+++ b/src/Core/Compiler/ScriptModel/Symbols/TypeSymbol.cs
@@ -33,6 +33,7 @@ internal abstract class TypeSymbol : Symbol, ISymbolTable {
         private bool _ignoreNamespace;
         private string _scriptNamespace;
         private bool _testType;
+        private bool _scriptImported;
 
         protected TypeSymbol(SymbolType type, string name, NamespaceSymbol parent)
             : base(type, name, parent) {
@@ -195,6 +196,12 @@ public string ScriptNamespace {
             }
         }
 
+        public bool IsScriptImported {
+            get {
+                return _scriptImported;
+            }
+        }
+
         public virtual void AddMember(MemberSymbol memberSymbol) {
             Debug.Assert(memberSymbol != null);
             Debug.Assert(String.IsNullOrEmpty(memberSymbol.Name) == false);
@@ -294,6 +301,10 @@ public void SetTestType() {
             _testType = true;
         }
 
+        internal void SetScriptImported() {
+            _scriptImported = true;
+        }
+
         #region ISymbolTable Members
         ICollection ISymbolTable.Symbols {
             get {
@@ -337,5 +348,6 @@ Symbol ISymbolTable.FindSymbol(string name, Symbol context, SymbolFilter filter)
             return symbol;
         }
         #endregion
+
     }
 }
diff --git a/src/Core/Compiler/SymbolFile/AjaxMinRenameFileGenerator.cs b/src/Core/Compiler/SymbolFile/AjaxMinRenameFileGenerator.cs
new file mode 100644
index 000000000..4ed2aac55
--- /dev/null
+++ b/src/Core/Compiler/SymbolFile/AjaxMinRenameFileGenerator.cs
@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml;
+using System.IO;
+
+namespace ScriptSharp.SymbolFile {
+    public class AjaxMinRenameFileGenerator {
+
+        internal const string RootElement = "root";
+        internal const string RenameElement = "rename";
+        internal const string NorenameElement = "norename";
+        internal const string IdAttribute = "id";
+        internal const string FromAttribute = "from";
+        internal const string ToAttribute = "to";
+
+        /// <summary>
+        /// Generate an AjaxMin rename file, based on Exported Symbols
+        /// </summary>
+        /// <param name="mfs">Merged symbol file</param>
+        /// <param name="amrf">AjaxMin rename file</param>
+        public void Generate(string symbol, string rename) {
+
+            string renames = @"//Symbol[@GeneratedName][ancestor::Symbol[@HasApplicationTypes='True']]";
+            string norenames = @"//Symbol[@GeneratedName][ancestor::Symbol[@HasApplicationTypes='False']] 
+                | //Symbol[@GeneratedName][ancestor::Symbol[@IsScriptImported='True']]
+                | //Symbol[@GeneratedName][@IsScriptImported='True']
+            ";
+
+            var xmsf = new XmlDocument();
+            xmsf.Load(symbol);
+
+            var renameNodes = xmsf.SelectNodes(renames);
+            var norenameNodes = xmsf.SelectNodes(norenames);
+
+            HashSet<string> norenameHash = new HashSet<string>();
+            foreach (XmlNode node in norenameNodes) {
+                string name = GetAttribute(node, SymbolFile.GeneratedNameAttribute);
+                norenameHash.Add(name);
+
+                // $.bbq.getstate get expanded as getstate
+                // otherwise ajaxmin will it
+                var names = name.Split(new[] { '.' });
+                string trailing = names[names.Length - 1];
+                norenameHash.Add(trailing);
+            }
+
+            HashSet<string> renameHash = new HashSet<string>();
+            foreach (XmlNode node in renameNodes) {
+                string name = GetAttribute(node, SymbolFile.GeneratedNameAttribute);
+                if (norenameHash.Contains(name)) {
+                    continue;
+                }
+                renameHash.Add(name);
+            }
+
+            GenerateFile(rename, norenameHash, renameHash);
+
+        }
+
+        private void GenerateFile(string rename, HashSet<string> norenameHash, HashSet<string> renameHash) {
+
+            using (XmlTextWriter writer = new XmlTextWriter(rename, Encoding.UTF8)) {
+
+                writer.WriteStartDocument();
+                writer.WriteStartElement(RootElement);
+
+                var seq = Generate(renameHash.Count);
+                var random = RandomPermutation<string>(seq).ToArray();
+
+                int i = 0;
+                foreach (string ren in renameHash) {
+                    writer.WriteStartElement(RenameElement);
+                    writer.WriteAttributeString(FromAttribute, ren);
+                    writer.WriteAttributeString(ToAttribute, random[i++]);
+                    writer.WriteEndElement();
+                }
+
+                foreach (string ren in norenameHash) {
+                    writer.WriteStartElement(NorenameElement);
+                    writer.WriteAttributeString(IdAttribute, ren);
+                    writer.WriteEndElement();
+                }
+
+                writer.WriteEndElement();
+                writer.WriteEndDocument();
+
+                writer.Flush();
+                writer.Close();
+
+            }
+
+        }
+
+        public static IEnumerable<string> Generate(int length) {
+            for (int i = 0; i < length; i++) {
+                yield return "x" + i;
+            }
+        }
+
+        static Random random = new Random();
+        public static IEnumerable<T> RandomPermutation<T>(IEnumerable<T> sequence) {
+            T[] retArray = sequence.ToArray();
+
+
+            for (int i = 0; i < retArray.Length - 1; i += 1) {
+                int swapIndex = random.Next(i + 1, retArray.Length);
+                T temp = retArray[i];
+                retArray[i] = retArray[swapIndex];
+                retArray[swapIndex] = temp;
+            }
+
+            return retArray;
+        }
+
+        string GetAttribute(XmlNode node, string attributeName) {
+            if (node == null) {
+                return null;
+            }
+            if (node.Attributes[attributeName] == null) {
+                return null;
+            }
+            return node.Attributes[attributeName].Value;
+        }
+    }
+}
diff --git a/src/Core/Compiler/SymbolFile/SymbolFile.cs b/src/Core/Compiler/SymbolFile/SymbolFile.cs
new file mode 100644
index 000000000..92c3a84b9
--- /dev/null
+++ b/src/Core/Compiler/SymbolFile/SymbolFile.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ScriptSharp.SymbolFile {
+    internal class SymbolFile {
+
+        internal const string RootElement = "Symbols";
+        internal const string SymbolElement = "Symbol";
+        internal const string GeneratedNameAttribute = "GeneratedName";
+        internal const string NameAttribute = "Name";
+        internal const string TypeAttribute = "Type";
+        internal const string HasApplicationTypesAttribute = "HasApplicationTypes";
+        internal const string IsExtenderClassAttribute = "IsExtenderClass";
+        internal const string BaseClassAttribute = "BaseClass";
+        internal const string FlagAttribute = "Flag";
+        internal const string ReadOnlyAttribute = "ReadOnly";
+        internal const string AssociatedTypeAttribute = "AssociatedType";
+        internal const string VisibilityAttribute = "Visibility";
+        internal const string ConditionsAttribute = "Conditions";
+        internal const string ValueTypeAttribute = "ValueType";
+        internal const string ModeAttribute = "Mode";
+        internal const string IsPublicAttribute = "IsPublic";
+        internal const string AbstractAttribute = "Abstract";
+        internal const string InterfaceMemberAttribute = "InterfaceMember";
+        internal const string SetterTypeName = "Setter";
+        internal const string GetterTypeName = "Getter";
+        internal const string AliasedAttribute = "IsAliased";
+        internal const string IsScriptImportedAttribute = "IsScriptImported";
+        
+
+    }
+}
diff --git a/src/Core/Compiler/SymbolFile/SymbolFileGenerator.cs b/src/Core/Compiler/SymbolFile/SymbolFileGenerator.cs
new file mode 100644
index 000000000..dd8eaa133
--- /dev/null
+++ b/src/Core/Compiler/SymbolFile/SymbolFileGenerator.cs
@@ -0,0 +1,323 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.CodeDom.Compiler;
+using ScriptSharp.ScriptModel;
+using System.IO;
+using System.Diagnostics;
+using System.Collections;
+using System.Xml;
+
+namespace ScriptSharp.SymbolFile {
+
+    /// <summary>
+    /// Generates symbol files from extracted symbol informations.
+    /// </summary>
+    internal class SymbolFileGenerator {
+
+
+        private readonly XmlTextWriter _writer;
+
+
+        internal SymbolFileGenerator(TextWriter writer) {
+            Debug.Assert(writer != null);
+
+            _writer = new XmlTextWriter(writer);
+
+        }
+
+        internal void Generate(SymbolSet symbols) {
+
+            _writer.WriteStartDocument();
+            _writer.WriteStartElement(SymbolFile.RootElement);
+
+            DumpSymbols(symbols);
+
+            _writer.WriteEndElement();
+            _writer.WriteEndDocument();
+
+        }
+        #region Dump
+
+
+        private void DumpSymbols(SymbolSet symbols) {
+            ArrayList namespaces = new ArrayList(symbols.Namespaces.Count);
+            foreach (NamespaceSymbol ns in symbols.Namespaces) {
+                namespaces.Add(ns);
+            }
+            namespaces.Sort(new SymbolComparer());
+
+            foreach (NamespaceSymbol ns in namespaces) {
+                DumpSymbol(ns);
+
+            }
+        }
+
+
+        private void WriteElement(Symbol s) {
+
+            _writer.WriteEndElement();
+
+        }
+
+        #endregion
+        private void DumpClass(ClassSymbol classSymbol) {
+
+            if (classSymbol.BaseClass != null) {
+                _writer.WriteAttributeString(SymbolFile.BaseClassAttribute, classSymbol.BaseClass.Name);
+            }
+            if (classSymbol.Interfaces != null) {
+                foreach (InterfaceSymbol interfaceSymbol in classSymbol.Interfaces) {
+                    _writer.WriteStartElement(SymbolFile.SymbolElement);
+                    _writer.WriteAttributeString(SymbolFile.TypeAttribute, interfaceSymbol.Type.ToString());
+                    _writer.WriteAttributeString(SymbolFile.NameAttribute, interfaceSymbol.Name);
+                    _writer.WriteEndElement();
+                }
+            }
+            if (classSymbol.Constructor != null) {
+                DumpSymbol(classSymbol.Constructor);
+            }
+            if (classSymbol.StaticConstructor != null) {
+                DumpSymbol(classSymbol.StaticConstructor);
+            }
+            if (classSymbol.Indexer != null) {
+                DumpSymbol(classSymbol.Indexer);
+            }
+        }
+
+        private void DumpConstructor(ConstructorSymbol ctorSymbol) {
+            if (ctorSymbol.Parameters != null) {
+
+                foreach (ParameterSymbol paramSymbol in ctorSymbol.Parameters) {
+                    DumpSymbol(paramSymbol);
+                }
+            }
+        }
+
+        private void DumpDelegate(DelegateSymbol delegateSymbol) {
+        }
+
+        private void DumpEnumeration(EnumerationSymbol enumSymbol) {
+            _writer.WriteAttributeString(SymbolFile.FlagAttribute, enumSymbol.Flags.ToString());
+        }
+
+        private void DumpEnumerationField(EnumerationFieldSymbol enumFieldSymbol) {
+        }
+
+        private void DumpEvent(EventSymbol eventSymbol) {
+
+            _writer.WriteStartElement(SymbolFile.SymbolElement);
+            _writer.WriteAttributeString(SymbolFile.TypeAttribute, SymbolFile.GetterTypeName);
+            _writer.WriteAttributeString(SymbolFile.NameAttribute, eventSymbol.Name);
+            _writer.WriteAttributeString(SymbolFile.GeneratedNameAttribute, "add_" + eventSymbol.GeneratedName);
+            _writer.WriteEndElement();
+
+            _writer.WriteStartElement(SymbolFile.SymbolElement);
+            _writer.WriteAttributeString(SymbolFile.TypeAttribute, SymbolFile.SetterTypeName);
+            _writer.WriteAttributeString(SymbolFile.NameAttribute, eventSymbol.Name);
+            _writer.WriteAttributeString(SymbolFile.GeneratedNameAttribute, "remove_" + eventSymbol.GeneratedName);
+            _writer.WriteEndElement();
+        }
+
+        private void DumpField(FieldSymbol fieldSymbol) {
+            _writer.WriteAttributeString(SymbolFile.AliasedAttribute, fieldSymbol.IsGlobalField.ToString());
+        }
+
+        private void DumpIndexer(IndexerSymbol indexerSymbol) {
+            _writer.WriteAttributeString(SymbolFile.ReadOnlyAttribute, indexerSymbol.IsReadOnly.ToString());
+            _writer.WriteAttributeString(SymbolFile.AbstractAttribute, indexerSymbol.IsAbstract.ToString());
+
+
+            _writer.WriteStartElement(SymbolFile.SymbolElement);
+            _writer.WriteAttributeString(SymbolFile.TypeAttribute, SymbolFile.GetterTypeName);
+            _writer.WriteAttributeString(SymbolFile.NameAttribute, indexerSymbol.Name);
+            _writer.WriteAttributeString(SymbolFile.GeneratedNameAttribute, "get_" + indexerSymbol.GeneratedName);
+            _writer.WriteEndElement();
+
+            _writer.WriteStartElement(SymbolFile.SymbolElement);
+            _writer.WriteAttributeString(SymbolFile.TypeAttribute, SymbolFile.SetterTypeName);
+            _writer.WriteAttributeString(SymbolFile.NameAttribute, indexerSymbol.Name);
+            _writer.WriteAttributeString(SymbolFile.GeneratedNameAttribute, "set_" + indexerSymbol.GeneratedName);
+            _writer.WriteEndElement();
+
+        }
+
+        private void DumpInterface(InterfaceSymbol interfaceSymbol) {
+        }
+
+        private void DumpMember(MemberSymbol memberSymbol) {
+
+            _writer.WriteAttributeString(SymbolFile.AssociatedTypeAttribute, memberSymbol.AssociatedType.Name.ToString());
+            _writer.WriteAttributeString(SymbolFile.VisibilityAttribute, memberSymbol.Visibility.ToString());
+            _writer.WriteAttributeString(SymbolFile.GeneratedNameAttribute, memberSymbol.GeneratedName);
+
+            if (memberSymbol.InterfaceMember != null) {
+                _writer.WriteAttributeString(SymbolFile.InterfaceMemberAttribute, string.Format(
+                    "{0}.{1}", memberSymbol.InterfaceMember.Parent.Name, memberSymbol.InterfaceMember.Name));
+            }
+
+            switch (memberSymbol.Type) {
+                case SymbolType.Field:
+                    DumpField((FieldSymbol)memberSymbol);
+                    break;
+                case SymbolType.EnumerationField:
+                    DumpEnumerationField((EnumerationFieldSymbol)memberSymbol);
+                    break;
+                case SymbolType.Constructor:
+                    DumpConstructor((ConstructorSymbol)memberSymbol);
+                    break;
+                case SymbolType.Property:
+                    DumpProperty((PropertySymbol)memberSymbol);
+                    break;
+                case SymbolType.Indexer:
+                    DumpIndexer((IndexerSymbol)memberSymbol);
+                    break;
+                case SymbolType.Event:
+                    DumpEvent((EventSymbol)memberSymbol);
+                    break;
+                case SymbolType.Method:
+                    DumpMethod((MethodSymbol)memberSymbol);
+                    break;
+            }
+
+        }
+
+        private void DumpMethod(MethodSymbol methodSymbol) {
+
+
+            _writer.WriteAttributeString(SymbolFile.AbstractAttribute, methodSymbol.IsAbstract.ToString());
+            _writer.WriteAttributeString(SymbolFile.AliasedAttribute, methodSymbol.IsAliased.ToString());
+            
+            if (methodSymbol.Conditions != null) {
+
+                StringBuilder sb = new StringBuilder();
+                foreach (string condition in methodSymbol.Conditions) {
+                    sb.Append(condition);
+                    sb.Append(",");
+                }
+                _writer.WriteAttributeString(SymbolFile.ConditionsAttribute, sb.ToString());
+            }
+
+            if (methodSymbol.Parameters != null) {
+
+                foreach (ParameterSymbol paramSymbol in methodSymbol.Parameters) {
+                    DumpSymbol(paramSymbol);
+                }
+
+            }
+        }
+
+        private void DumpNamespace(NamespaceSymbol namespaceSymbol) {
+
+            _writer.WriteAttributeString(SymbolFile.HasApplicationTypesAttribute, namespaceSymbol.HasApplicationTypes.ToString());
+
+            ArrayList types = new ArrayList(namespaceSymbol.Types.Count);
+            foreach (TypeSymbol type in namespaceSymbol.Types) {
+                types.Add(type);
+            }
+            types.Sort(new SymbolComparer());
+
+            foreach (TypeSymbol type in types) {
+                DumpSymbol(type);
+            }
+        }
+
+        private void DumpParameter(ParameterSymbol parameterSymbol) {
+            _writer.WriteAttributeString(SymbolFile.ValueTypeAttribute, parameterSymbol.ValueType.Name);
+            _writer.WriteAttributeString(SymbolFile.ModeAttribute, parameterSymbol.Mode.ToString());
+        }
+
+        private void DumpProperty(PropertySymbol propertySymbol) {
+            _writer.WriteAttributeString(SymbolFile.ReadOnlyAttribute, propertySymbol.IsReadOnly.ToString());
+            _writer.WriteAttributeString(SymbolFile.AbstractAttribute, propertySymbol.IsAbstract.ToString());
+
+            _writer.WriteStartElement(SymbolFile.SymbolElement);
+            _writer.WriteAttributeString(SymbolFile.TypeAttribute, SymbolFile.GetterTypeName);
+            _writer.WriteAttributeString(SymbolFile.NameAttribute, propertySymbol.Name);
+            _writer.WriteAttributeString(SymbolFile.GeneratedNameAttribute, "get_" + propertySymbol.GeneratedName);
+            _writer.WriteEndElement();
+
+            _writer.WriteStartElement(SymbolFile.SymbolElement);
+            _writer.WriteAttributeString(SymbolFile.TypeAttribute, SymbolFile.SetterTypeName);
+            _writer.WriteAttributeString(SymbolFile.NameAttribute, propertySymbol.Name);
+            _writer.WriteAttributeString(SymbolFile.GeneratedNameAttribute, "set_" + propertySymbol.GeneratedName);
+            _writer.WriteEndElement();
+
+        }
+
+        private void DumpSymbol(Symbol symbol) {
+
+            _writer.WriteStartElement(SymbolFile.SymbolElement);
+            _writer.WriteAttributeString(SymbolFile.TypeAttribute, symbol.Type.ToString());
+            _writer.WriteAttributeString(SymbolFile.NameAttribute, symbol.Name);
+
+            switch (symbol.Type) {
+                case SymbolType.Namespace:
+                    DumpNamespace((NamespaceSymbol)symbol);
+                    break;
+                case SymbolType.Class:
+                case SymbolType.Interface:
+                case SymbolType.Enumeration:
+                case SymbolType.Delegate:
+                case SymbolType.Record:
+                    DumpType((TypeSymbol)symbol);
+                    break;
+                case SymbolType.Field:
+                case SymbolType.EnumerationField:
+                case SymbolType.Constructor:
+                case SymbolType.Property:
+                case SymbolType.Indexer:
+                case SymbolType.Event:
+                case SymbolType.Method:
+                    DumpMember((MemberSymbol)symbol);
+                    break;
+                case SymbolType.Parameter:
+                    DumpParameter((ParameterSymbol)symbol);
+                    break;
+            }
+
+            _writer.WriteEndElement();
+
+        }
+
+        private void DumpType(TypeSymbol typeSymbol) {
+
+            _writer.WriteAttributeString(SymbolFile.IsExtenderClassAttribute, typeSymbol.IsApplicationType.ToString());
+            _writer.WriteAttributeString(SymbolFile.IsPublicAttribute, typeSymbol.IsPublic.ToString());
+            _writer.WriteAttributeString(SymbolFile.IsScriptImportedAttribute, typeSymbol.IsScriptImported.ToString());
+
+            _writer.WriteAttributeString(SymbolFile.GeneratedNameAttribute, typeSymbol.GeneratedName);
+
+            switch (typeSymbol.Type) {
+                case SymbolType.Class:
+                case SymbolType.Record:
+                    DumpClass((ClassSymbol)typeSymbol);
+                    break;
+                case SymbolType.Interface:
+                    DumpInterface((InterfaceSymbol)typeSymbol);
+                    break;
+                case SymbolType.Enumeration:
+                    DumpEnumeration((EnumerationSymbol)typeSymbol);
+                    break;
+                case SymbolType.Delegate:
+                    DumpDelegate((DelegateSymbol)typeSymbol);
+                    break;
+            }
+
+            foreach (MemberSymbol member in typeSymbol.Members) {
+                DumpSymbol(member);
+            }
+
+        }
+        private sealed class SymbolComparer : IComparer {
+
+            public int Compare(object x, object y) {
+                return String.Compare(((Symbol)x).Name, ((Symbol)y).Name);
+            }
+        }
+
+
+
+    }
+}
diff --git a/src/Core/Compiler/SymbolFile/SymbolFileMerger.cs b/src/Core/Compiler/SymbolFile/SymbolFileMerger.cs
new file mode 100644
index 000000000..c35c32df6
--- /dev/null
+++ b/src/Core/Compiler/SymbolFile/SymbolFileMerger.cs
@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml;
+using System.IO;
+
+namespace ScriptSharp.SymbolFile {
+
+    /// <summary>
+    /// Merges multiple symbol files into a single one
+    /// </summary>
+    public class SymbolFileMerger {
+
+        public bool Merge(string[] symbols, string mergefile, out string error) {
+
+            bool success = false;
+            try {
+                TryMerge(symbols, mergefile);
+                success = true;
+                error = null;
+            } catch (Exception e) {
+                error = e.ToString();
+            }
+            return success;
+        }
+
+        private void TryMerge(string[] symbols, string mergefile) {
+
+            var merged = new XmlDocument();
+            XmlElement root = merged.CreateElement(SymbolFile.RootElement);
+            merged.AppendChild(root);
+
+            foreach (var symbol in symbols) {
+                var xml = new XmlDocument();
+                xml.Load(symbol);
+
+                string namespaces = string.Format("/{0}/{1}[@{2}='Namespace']", SymbolFile.RootElement, SymbolFile.SymbolElement, SymbolFile.TypeAttribute);
+                foreach (XmlNode node in xml.SelectNodes(namespaces)) {
+                    MergeNamespace(merged, root, node);
+                }
+            }
+
+            merged.Save(mergefile);
+        }
+
+        private void MergeNamespace(XmlDocument merged, XmlElement root, XmlNode node) {
+
+            string name = node.Attributes["Name"] == null ? null : node.Attributes["Name"].Value;
+            string ns = string.Format("/{0}/{1}[@{2}='Namespace'][@{3}='{4}']", SymbolFile.RootElement, SymbolFile.SymbolElement, SymbolFile.TypeAttribute, SymbolFile.NameAttribute, name);
+
+            var exists = merged.SelectSingleNode(ns);
+            bool existsHasApplicationType = HasApplicationAttribue(exists);
+            bool nodeHasApplicationType = HasApplicationAttribue(node);
+
+            if (exists == null) {
+                var imported = merged.ImportNode(node, true);
+                root.AppendChild(imported);
+            } else if (exists != null
+                  && !existsHasApplicationType
+                  && nodeHasApplicationType) {
+                root.RemoveChild(exists);
+                var imported = merged.ImportNode(node, true);
+                root.AppendChild(imported);
+            }
+        }
+
+        private bool HasApplicationAttribue(XmlNode node) {
+            if (node == null) {
+                return false;
+            }
+            if (node.Attributes[SymbolFile.HasApplicationTypesAttribute] == null) {
+                return false;
+            }
+            bool value = false;
+            bool.TryParse(node.Attributes[SymbolFile.HasApplicationTypesAttribute].Value, out value);
+            return value;
+        }
+    }
+}
diff --git a/src/ScriptSharp.sln b/src/ScriptSharp.sln
index fef45edef..055b248d4 100644
--- a/src/ScriptSharp.sln
+++ b/src/ScriptSharp.sln
@@ -1,6 +1,6 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2012
+# Visual Studio 2010
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "jQuery.Core", "Libraries\jQuery\jQuery.Core\jQuery.Core.csproj", "{4A9F7CE0-5A45-4B28-AD01-05528709B6E4}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Web", "Libraries\Web\Web.csproj", "{3681A9A8-FC40-4125-B842-7775713C8DCE}"
diff --git a/src/Tools/Deployment/Deployment.csproj b/src/Tools/Deployment/Deployment.csproj
index 6d7a332df..3dd0e1a1d 100644
--- a/src/Tools/Deployment/Deployment.csproj
+++ b/src/Tools/Deployment/Deployment.csproj
@@ -33,6 +33,11 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="AjaxMin, Version=4.73.4685.17665, Culture=neutral, PublicKeyToken=21ef50ce11b5d80f, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\tools\ext\AjaxMin.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
     <Reference Include="Microsoft.Build" />
     <Reference Include="Microsoft.Build.Framework" />
     <Reference Include="Microsoft.Build.Utilities" />
@@ -40,6 +45,8 @@
     <Reference Include="System.XML" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Obfuscator\AjaxMinObfuscator.cs" />
+    <Compile Include="Obfuscator\ObfuscationStyleEnum.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="..\..\ScriptSharp.cs">
       <Link>Properties\ScriptSharp.cs</Link>
@@ -49,8 +56,16 @@
   <ItemGroup>
     <Content Include="ScriptSharpWeb.targets">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <SubType>Designer</SubType>
     </Content>
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Core\Compiler\Compiler.csproj">
+      <Project>{9F14036F-673F-418E-B817-7E2289D7F3F6}</Project>
+      <Name>Compiler</Name>
+      <Private>False</Private>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/src/Tools/Deployment/Obfuscator/AjaxMinObfuscator.cs b/src/Tools/Deployment/Obfuscator/AjaxMinObfuscator.cs
new file mode 100644
index 000000000..f87a5eadf
--- /dev/null
+++ b/src/Tools/Deployment/Obfuscator/AjaxMinObfuscator.cs
@@ -0,0 +1,203 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Ajax.Utilities;
+using System.IO;
+using System.Xml;
+
+namespace ScriptSharp.Tasks.Obfuscator {
+    public class AjaxMinObfuscator {
+
+        private readonly string _obfuscationStyle;
+        private ObfuscationStyleEnum ObfuscationStyle {
+            get {
+                var sstyle = !string.IsNullOrEmpty(_obfuscationStyle)
+                    ? _obfuscationStyle
+                    : "Full";
+
+                var style = ObfuscationStyleEnum.Full;
+                Enum.TryParse<ObfuscationStyleEnum>(value: sstyle, ignoreCase: true, result: out style);
+                return style;
+
+            }
+        }
+
+        public AjaxMinObfuscator(string obfuscationStyle) {
+            _obfuscationStyle = obfuscationStyle;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="obfuscationStyle">
+        /// X : prefix obfuscated symbol with a X (helps with debugging obfuscated code)</param>
+        /// Full : fully obfuscate symbols
+        /// None : disable obfuscation
+        /// </param>
+        public void Obfuscate(IEnumerable<string> scripts, string renamefile, string obfuscatedfile) {
+
+
+            var merged = Merge(scripts);
+            var norenames = ReadNoRename(renamefile);
+            var renames = ReadRename(renamefile);
+            ShuffleRenameKeys(renames);
+            var obfuscated = Obfuscate(merged, norenames, renames);
+
+            File.WriteAllText(obfuscatedfile, obfuscated);
+        }
+
+
+        private void ShuffleRenameKeys(List<RenamePair> renames) {
+
+            int count = renames.Count();
+            var obfid = Generate(count);
+            var permutation = RandomPermutation(count);
+            var shuffled = Shuffle(obfid, permutation);
+
+            for (int i = 0; i < count; i++) {
+
+                string rename = shuffled[i];
+                switch (ObfuscationStyle) {
+                    case ObfuscationStyleEnum.X:
+                        rename = "x" + renames[i].From;
+                        break;
+                    case ObfuscationStyleEnum.Full:
+                        rename = shuffled[i];
+                        break;
+                    default:
+                        rename = renames[i].From;
+                        break;
+                }
+                renames[i].To = rename;
+            }
+
+        }
+
+        public static int[] RandomPermutation(int length) {
+
+            int[] arr = new int[length];
+
+            for (int i = 0; i < arr.Length - 1; i++) {
+                int swapIndex = Random.Next(i + 1, arr.Length);
+                arr[i] = swapIndex;
+            }
+
+            return arr;
+        }
+
+        public static IEnumerable<string> Generate(int length) {
+            for (int i = 0; i < length; i++) {
+                yield return "x" + i;
+            }
+        }
+
+        static Random Random = new Random();
+        public static T[] Shuffle<T>(IEnumerable<T> sequence, int[] permutation) {
+
+            T[] retArray = sequence.ToArray();
+            for (int i = 0; i < retArray.Length - 1; i += 1) {
+                int swapIndex = permutation[i];
+                T temp = retArray[i];
+                retArray[i] = retArray[swapIndex];
+                retArray[swapIndex] = temp;
+            }
+
+            return retArray;
+        }
+
+        string Merge(IEnumerable<string> files) {
+
+            using (var output = new MemoryStream()) {
+
+                foreach (var file in files) {
+                    using (var input = File.OpenRead(file)) {
+                        input.CopyTo(output);
+                    }
+                }
+
+                return Encoding.UTF8.GetString(output.ToArray());
+            }
+
+        }
+
+        IEnumerable<string> ReadNoRename(string fmap) {
+
+            using (var file = new FileStream(fmap, FileMode.Open, FileAccess.Read, FileShare.Read)) {
+
+                var xml = new XmlDocument();
+                xml.Load(file);
+                var nodes = xml.SelectNodes("//norename[@id]");
+                List<string> norenames = new List<string>();
+                foreach (XmlNode node in nodes) {
+                    string norename = node.Attributes["id"].Value;
+                    norenames.Add(norename);
+                }
+
+                return norenames;
+            }
+
+        }
+
+        internal class RenamePair {
+            internal RenamePair(string from, string to) {
+                From = from;
+                To = to;
+            }
+            internal string From;
+            internal string To;
+        }
+
+        List<RenamePair> ReadRename(string fmap) {
+
+            using (var file = new FileStream(fmap, FileMode.Open, FileAccess.Read, FileShare.Read)) {
+
+                var xml = new XmlDocument();
+                xml.Load(file);
+                var nodes = xml.SelectNodes("//rename[@from][@to]");
+                List<RenamePair> rename = new List<RenamePair>();
+                foreach (XmlNode node in nodes) {
+                    string from = node.Attributes["from"].Value;
+                    string to = node.Attributes["to"].Value;
+                    var t = new RenamePair(from, to);
+                    rename.Add(t);
+                }
+
+                return rename;
+            }
+
+        }
+
+        Microsoft.Ajax.Utilities.OutputMode GetOutputMode(ObfuscationStyleEnum style) {
+            var dic = new Dictionary<ObfuscationStyleEnum, OutputMode> {
+                { ObfuscationStyleEnum.None, OutputMode.MultipleLines },
+                { ObfuscationStyleEnum.X, OutputMode.MultipleLines },
+                { ObfuscationStyleEnum.Full, OutputMode.SingleLine }
+            };
+
+            return dic.ContainsKey(style) ? dic[style] : OutputMode.SingleLine;
+        }
+
+        string Obfuscate(string script, IEnumerable<string> norenames, IEnumerable<RenamePair> renames) {
+
+            var minifier = new Minifier();
+            var settings = new CodeSettings() {
+                StripDebugStatements = true,
+                OutputMode = GetOutputMode(ObfuscationStyle),
+                IgnorePreprocessorDefines = true,
+                IgnoreConditionalCompilation = true,
+                MinifyCode = ObfuscationStyle == ObfuscationStyleEnum.None ? false : true
+            };
+
+            foreach (var s in norenames) { settings.AddNoAutoRename(s); };
+            foreach (var p in renames) { settings.AddRenamePair(p.From, p.To); };
+
+            settings.SetDebugNamespaces(null);
+
+            string obfuscated = minifier.MinifyJavaScript(script, settings);
+            return obfuscated;
+        }
+
+
+    }
+}
diff --git a/src/Tools/Deployment/Obfuscator/ObfuscationStyleEnum.cs b/src/Tools/Deployment/Obfuscator/ObfuscationStyleEnum.cs
new file mode 100644
index 000000000..3737b7745
--- /dev/null
+++ b/src/Tools/Deployment/Obfuscator/ObfuscationStyleEnum.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ScriptSharp.Tasks.Obfuscator {
+    public enum ObfuscationStyleEnum {
+            X,
+            Full,
+            None
+    }
+}
diff --git a/src/Tools/Deployment/ScriptDeployTask.cs b/src/Tools/Deployment/ScriptDeployTask.cs
index 1c23feb45..cbb1e1adf 100644
--- a/src/Tools/Deployment/ScriptDeployTask.cs
+++ b/src/Tools/Deployment/ScriptDeployTask.cs
@@ -10,6 +10,9 @@
 using Microsoft.Build.Evaluation;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
+using System.Diagnostics;
+using ScriptSharp.SymbolFile;
+using ScriptSharp.Tasks.Obfuscator;
 
 namespace ScriptSharp.Tasks {
 
@@ -17,6 +20,7 @@ public sealed class ScriptDeployTask : Task {
 
         private string _projectPath;
         private string _scriptsPath;
+        private string _obfuscationStyle;
         private ITaskItem[] _references;
 
         private HashSet<string> _scriptSet;
@@ -64,6 +68,17 @@ public string ScriptsPath {
             }
         }
 
+        public string ObfuscationStyle {
+            get {
+                return String.IsNullOrEmpty(_obfuscationStyle) 
+                    ? "None"
+                    : _obfuscationStyle;
+            }
+            set {
+                _obfuscationStyle = value;
+            }
+        }
+
         private void CopyFile(string sourceFilePath, string targetFilePath) {
             if (File.Exists(targetFilePath)) {
                 // If the file already exists, make sure it is not read-only, so
@@ -106,6 +121,98 @@ private void DeployScripts(string projectName, string scriptsFile, string projec
             }
         }
 
+        private void DeploySymbols(string projectName, string scriptsFile, string projectPath, string targetPath) {
+
+            string sourceDirectory = Path.GetDirectoryName(scriptsFile);
+            string[] symbols = File.ReadAllLines(scriptsFile);
+            string mergedfile = Path.ChangeExtension(projectName, "merged.symbol");
+            string mergedpath = Path.Combine(sourceDirectory, mergedfile);
+
+            symbols = symbols
+                .Where(s => Path.GetExtension(s) == ".symbol")
+                .Select(s => Path.Combine(sourceDirectory, s)).ToArray();
+
+            Log.LogMessage("Merging symbol file from {0} project:", projectName);
+
+            var sfm = new SymbolFileMerger();
+            string error;
+            bool success = sfm.Merge(symbols, mergedpath, out error);
+            if (!success) {
+                Log.LogError("Error merging symbol from project {0}.\r\n{1}", projectName, error);
+            }
+
+            Uri baseUri = new Uri(projectPath, UriKind.Absolute);
+            Uri targetUri = new Uri(mergedpath, UriKind.Absolute);
+            string relativePath = Uri.UnescapeDataString(baseUri.MakeRelativeUri(targetUri).ToString()).Replace("/", "\\");
+
+            string targetmergepath = Path.Combine(targetPath, mergedfile);
+            CopyFile(mergedpath, targetmergepath);
+
+            Log.LogMessage("-> " + relativePath);
+            _scripts.Add(new TaskItem(relativePath));
+
+        }
+
+        private void DeployAjaxMinRenameFile(string projectName, string scriptsFile, string projectPath, string targetPath) {
+
+            string sourceDirectory = Path.GetDirectoryName(scriptsFile);
+            string[] symbols = File.ReadAllLines(scriptsFile);
+            string mergedfile = Path.ChangeExtension(projectName, "merged.symbol");
+            string renamefile = Path.ChangeExtension(projectName, "rename.xml");
+            string mergedpath = Path.Combine(sourceDirectory, mergedfile);
+            string renamepath = Path.Combine(sourceDirectory, renamefile);
+            
+            Log.LogMessage("Creating AjaxMin rename file from {0} project:", projectName);
+
+            var amfg = new AjaxMinRenameFileGenerator();
+            amfg.Generate(mergedpath, renamepath);
+
+            Uri baseUri = new Uri(projectPath, UriKind.Absolute);
+            Uri targetUri = new Uri(renamepath, UriKind.Absolute);
+            string relativePath = Uri.UnescapeDataString(baseUri.MakeRelativeUri(targetUri).ToString()).Replace("/", "\\");
+
+            string targetrenamepath = Path.Combine(targetPath, renamefile);
+            CopyFile(renamepath, targetrenamepath);
+
+            Log.LogMessage("-> " + relativePath);
+            _scripts.Add(new TaskItem(relativePath));
+
+        }
+
+        private void Obfuscate(string projectName, string scriptsFile, string projectPath, string targetPath) {
+
+            string sourceDirectory = Path.GetDirectoryName(scriptsFile);
+            IEnumerable<string> scripts = from f in File.ReadAllLines(scriptsFile)
+                                          where f.EndsWith(".js") 
+                                            && string.Compare(f, "ss.js", ignoreCase: true) != 0
+                                            && string.Compare(f, "ss.min.js", ignoreCase: true) != 0
+                                          select Path.Combine(sourceDirectory, f);
+            
+            string renamefile = Path.ChangeExtension(projectName, "rename.xml");
+            string obfuscatedfile = Path.ChangeExtension(projectName, "obfusacted.js");
+
+            string renamepath = Path.Combine(sourceDirectory, renamefile);
+            string obfuscatedpath = Path.Combine(sourceDirectory, obfuscatedfile);
+
+            Log.LogMessage("Obfuscating files from {0} project:", projectName);
+
+            var amo = new AjaxMinObfuscator(ObfuscationStyle);
+            amo.Obfuscate(scripts, renamepath, obfuscatedpath);
+
+            Uri baseUri = new Uri(projectPath, UriKind.Absolute);
+            Uri targetUri = new Uri(obfuscatedpath, UriKind.Absolute);
+            string relativePath = Uri.UnescapeDataString(baseUri.MakeRelativeUri(targetUri).ToString()).Replace("/", "\\");
+
+            string targetrenamepath = Path.Combine(targetPath, obfuscatedfile);
+            CopyFile(obfuscatedpath, targetrenamepath);
+
+            Log.LogMessage("-> " + relativePath);
+            _scripts.Add(new TaskItem(relativePath));
+
+        }
+
+       
+
         public override bool Execute() {
             _scriptSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
             _scripts = new List<ITaskItem>();
@@ -143,6 +250,30 @@ public override bool Execute() {
                     Log.LogError("Error deploying scripts from project {0}.\r\n{1}", referenceName, e.ToString());
                     return false;
                 }
+                
+                try {
+                    DeploySymbols(referenceName, scriptsFile, _projectPath, scriptsDirectory);
+                } 
+                catch (Exception e) {
+                    Log.LogError("Error deploying symbols from project {0}.\r\n{1}", referenceName, e.ToString());
+                    return false;
+                }
+
+                try {
+                    DeployAjaxMinRenameFile(referenceName, scriptsFile, _projectPath, scriptsDirectory);
+                } 
+                catch (Exception e) {
+                    Log.LogError("Error creating AjaxMin rename file from project {0}.\r\n{1}", referenceName, e.ToString());
+                    return false;
+                }
+
+                try {
+                    Obfuscate(referenceName, scriptsFile, _projectPath, scriptsDirectory);
+                } 
+                catch (Exception e) {
+                    Log.LogError("Error obfuscating project {0}.\r\n{1}", referenceName, e.ToString());
+                    return false;
+                }
             }
 
             return true;
@@ -160,6 +291,19 @@ private string GetScriptsFile(Project project, string projectPath) {
             return scriptsFilePath;
         }
 
+
+        private string GetSymbolFile(Project project, string projectPath) {
+            string outputPath = project.GetProperty("OutputPath").EvaluatedValue;
+            string assemblyName = project.GetProperty("AssemblyName").EvaluatedValue;
+
+            string symbolFilePath = Path.Combine(Path.GetDirectoryName(projectPath), outputPath, assemblyName + ".symbol");
+            if (File.Exists(symbolFilePath) == false) {
+                return null;
+            }
+
+            return symbolFilePath;
+        }
+
         private Project GetReferencedProject(string projectPath) {
             ProjectCollection projects = ProjectCollection.GlobalProjectCollection;
             ICollection<Project> loadedProjects = projects.GetLoadedProjects(projectPath);
diff --git a/src/Tools/Deployment/ScriptSharpWeb.targets b/src/Tools/Deployment/ScriptSharpWeb.targets
index 4264b3a96..c06f80ed6 100644
--- a/src/Tools/Deployment/ScriptSharpWeb.targets
+++ b/src/Tools/Deployment/ScriptSharpWeb.targets
@@ -14,11 +14,12 @@ Copyright (c) 2013. Script# Project. All rights reserved.
     <ScriptDeployTask
       References="@(ProjectReference)"
       ScriptsPath="$(ScriptsPath)"
+      ObfuscationStyle="$(ObfuscationStyle)"
       ProjectPath="$(MSBuildProjectFullPath)">
       <Output TaskParameter="Scripts" ItemName="DeployedScripts" />
     </ScriptDeployTask>
     <ItemGroup>
-      <Content Include="@(DeployedScripts)" KeepDuplicates="False" />
+      <Content Include="@(DeployedScripts)" />
     </ItemGroup>
   </Target>
 
diff --git a/tools/ext/AjaxMin.dll b/tools/ext/AjaxMin.dll
index e4dd2cf6a..cb02406f5 100644
Binary files a/tools/ext/AjaxMin.dll and b/tools/ext/AjaxMin.dll differ
diff --git a/tools/ext/AjaxMin.pdb b/tools/ext/AjaxMin.pdb
new file mode 100644
index 000000000..f38cc2abb
Binary files /dev/null and b/tools/ext/AjaxMin.pdb differ