diff --git a/CHANGELOG.md b/CHANGELOG.md
index 959149f..0d6af5d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,9 @@
 ## 0.13.0
  * Add support for compact number formats ("1.2K") and for significant digits in
    number formats.
+ * Add a NumberFormat.simpleCurrency constructor which will attempt to
+   automatically determine the currency symbol. Very simple implementation but
+   can be expanded to be per-locale.
 
 ## 0.12.7+1
  * Change the signature for args and examples in Intl.plural/gender/select to
diff --git a/lib/src/intl/number_format.dart b/lib/src/intl/number_format.dart
index 62a37ea..fb57102 100644
--- a/lib/src/intl/number_format.dart
+++ b/lib/src/intl/number_format.dart
@@ -239,6 +239,228 @@
       : this._forPattern(locale, (x) => x.CURRENCY_PATTERN,
             name: name, currencySymbol: symbol, decimalDigits: decimalDigits);
 
+  /// Creates a [NumberFormat] for currencies, using the simple symbol for the
+  /// currency if one is available (e.g. $, €), so it should only be used if the
+  /// short currency symbol will be unambiguous.
+  ///
+  /// If [locale] is not specified, it will use the current default locale.
+  ///
+  /// If [name] is specified, the currency with that ISO 4217 name will be used.
+  /// Otherwise we will use the default currency name for the current locale. We
+  /// will assume that the symbol for this is well known in the locale and
+  /// unambiguous. If you format CAD in an en_US locale using this format it
+  /// will display as "$", which may be confusing to the user.
+  ///
+  /// If [decimalDigits] is specified, numbers will format with that many digits
+  /// after the decimal place. If it's not, they will use the default for the
+  /// currency in [name], and the default currency for [locale] if the currency
+  /// name is not specified. e.g.
+  ///       new NumberFormat.simpleCurrency(name: 'USD', decimalDigits: 7)
+  /// will format with 7 decimal digits, because that's what we asked for. But
+  ///       new NumberFormat.simpleCurrency(locale: 'en_US', name: 'JPY')
+  /// will format with zero, because that's the default for JPY, and the
+  /// currency's default takes priority over the locale's default.
+  ///       new NumberFormat.simpleCurrency(locale: 'en_US')
+  /// will format with two, which is the default for that locale.
+  factory NumberFormat.simpleCurrency(
+      {String locale, String name, int decimalDigits}) {
+    return new NumberFormat._forPattern(locale, (x) => x.CURRENCY_PATTERN,
+        name: name,
+        currencySymbol: _simpleCurrencySymbols[name] ?? name,
+        decimalDigits: decimalDigits);
+  }
+
+  /// Returns the simple currency symbol for given currency code, or
+  /// [currencyCode] if no simple symbol is listed.
+  ///
+  /// The simple currency symbol is generally short, and the same or related to
+  /// what is used in countries having the currency as an official symbol. It
+  /// may be a symbol character, or may have letters, or both. It may be
+  /// different according to the locale: for example, for an Arabic locale it
+  /// may consist of Arabic letters, but for a French locale consist of Latin
+  /// letters. It will not be unique: for example, "$" can appear for both USD
+  /// and CAD.
+  ///
+  /// (The current implementation is the same for all locales, but this is
+  /// temporary and callers shouldn't rely on it.)
+  String simpleCurrencySymbol(String currencyCode) =>
+      _simpleCurrencySymbols[currencyCode] ?? currencyCode;
+
+  /// A map from currency names to the simple name/symbol.
+  ///
+  /// The simple currency symbol is generally short, and the same or related to
+  /// what is used in countries having the currency as an official symbol. It
+  /// may be a symbol character, or may have letters, or both. It may be
+  /// different according to the locale: for example, for an Arabic locale it
+  /// may consist of Arabic letters, but for a French locale consist of Latin
+  /// letters. It will not be unique: for example, "$" can appear for both USD
+  /// and CAD.
+  ///
+  /// (The current implementation is the same for all locales, but this is
+  /// temporary and callers shouldn't rely on it.)
+  static Map<String, String> _simpleCurrencySymbols = {
+    "AFN": "Af.",
+    "TOP": r"T$",
+    "MGA": "Ar",
+    "THB": "\u0e3f",
+    "PAB": "B/.",
+    "ETB": "Birr",
+    "VEF": "Bs",
+    "BOB": "Bs",
+    "GHS": "GHS",
+    "CRC": "\u20a1",
+    "NIO": r"C$",
+    "GMD": "GMD",
+    "MKD": "din",
+    "BHD": "din",
+    "DZD": "din",
+    "IQD": "din",
+    "JOD": "din",
+    "KWD": "din",
+    "LYD": "din",
+    "RSD": "din",
+    "TND": "din",
+    "AED": "dh",
+    "MAD": "dh",
+    "STD": "Db",
+    "BSD": r"$",
+    "FJD": r"$",
+    "GYD": r"$",
+    "KYD": r"$",
+    "LRD": r"$",
+    "SBD": r"$",
+    "SRD": r"$",
+    "AUD": r"$",
+    "BBD": r"$",
+    "BMD": r"$",
+    "BND": r"$",
+    "BZD": r"$",
+    "CAD": r"$",
+    "HKD": r"$",
+    "JMD": r"$",
+    "NAD": r"$",
+    "NZD": r"$",
+    "SGD": r"$",
+    "TTD": r"$",
+    "TWD": r"NT$",
+    "USD": r"$",
+    "XCD": r"$",
+    "VND": "\u20ab",
+    "AMD": "Dram",
+    "CVE": "CVE",
+    "EUR": "\u20ac",
+    "AWG": "Afl.",
+    "HUF": "Ft",
+    "BIF": "FBu",
+    "CDF": "FrCD",
+    "CHF": "CHF",
+    "DJF": "Fdj",
+    "GNF": "FG",
+    "RWF": "RF",
+    "XOF": "CFA",
+    "XPF": "FCFP",
+    "KMF": "CF",
+    "XAF": "FCFA",
+    "HTG": "HTG",
+    "PYG": "Gs",
+    "UAH": "\u20b4",
+    "PGK": "PGK",
+    "LAK": "\u20ad",
+    "CZK": "K\u010d",
+    "SEK": "kr",
+    "ISK": "kr",
+    "DKK": "kr",
+    "NOK": "kr",
+    "HRK": "kn",
+    "MWK": "MWK",
+    "ZMK": "ZWK",
+    "AOA": "Kz",
+    "MMK": "K",
+    "GEL": "GEL",
+    "LVL": "Ls",
+    "ALL": "Lek",
+    "HNL": "L",
+    "SLL": "SLL",
+    "MDL": "MDL",
+    "RON": "RON",
+    "BGN": "lev",
+    "SZL": "SZL",
+    "TRY": "TL",
+    "LTL": "Lt",
+    "LSL": "LSL",
+    "AZN": "man.",
+    "BAM": "KM",
+    "MZN": "MTn",
+    "NGN": "\u20a6",
+    "ERN": "Nfk",
+    "BTN": "Nu.",
+    "MRO": "MRO",
+    "MOP": "MOP",
+    "CUP": r"$",
+    "CUC": r"$",
+    "ARS": r"$",
+    "CLF": "UF",
+    "CLP": r"$",
+    "COP": r"$",
+    "DOP": r"$",
+    "MXN": r"$",
+    "PHP": "\u20b1",
+    "UYU": r"$",
+    "FKP": "£",
+    "GIP": "£",
+    "SHP": "£",
+    "EGP": "E£",
+    "LBP": "L£",
+    "SDG": "SDG",
+    "SSP": "SSP",
+    "GBP": "£",
+    "SYP": "£",
+    "BWP": "P",
+    "GTQ": "Q",
+    "ZAR": "R",
+    "BRL": r"R$",
+    "OMR": "Rial",
+    "QAR": "Rial",
+    "YER": "Rial",
+    "IRR": "Rial",
+    "KHR": "Riel",
+    "MYR": "RM",
+    "SAR": "Rial",
+    "BYR": "BYR",
+    "RUB": "руб.",
+    "MUR": "Rs",
+    "SCR": "SCR",
+    "LKR": "Rs",
+    "NPR": "Rs",
+    "INR": "\u20b9",
+    "PKR": "Rs",
+    "IDR": "Rp",
+    "ILS": "\u20aa",
+    "KES": "Ksh",
+    "SOS": "SOS",
+    "TZS": "TSh",
+    "UGX": "UGX",
+    "PEN": "S/.",
+    "KGS": "KGS",
+    "UZS": "so\u02bcm",
+    "TJS": "Som",
+    "BDT": "\u09f3",
+    "WST": "WST",
+    "KZT": "\u20b8",
+    "MNT": "\u20ae",
+    "VUV": "VUV",
+    "KPW": "\u20a9",
+    "KRW": "\u20a9",
+    "JPY": "¥",
+    "CNY": "¥",
+    "PLN": "z\u0142",
+    "MVR": "Rf",
+    "NLG": "NAf",
+    "ZMW": "ZK",
+    "ANG": "ƒ",
+    "TMT": "TMT",
+  };
+
   /// Create a number format that prints in a pattern we get from
   /// the [getPattern] function using the locale [locale].
   NumberFormat._forPattern(String locale, _PatternGetter getPattern,
@@ -377,7 +599,11 @@
   /// Helper to round a number which might not be num.
   _round(number) {
     if (number is num) {
-      return number.round();
+      if (number.isInfinite) {
+        return _maxInt;
+      } else {
+        return number.round();
+      }
     } else if (number.remainder(1) == 0) {
       // Not a normal number, but int-like, e.g. Int64
       return number;
@@ -697,6 +923,7 @@
   _NumberParser(this.format, text)
       : this.text = text,
         this.input = new _Stream(text) {
+    scale = format._internalMultiplier;
     value = parse();
   }
 
@@ -797,6 +1024,16 @@
   /// that's not a digit and doesn't have a replacement, then we're done
   /// and the number is probably invalid.
   void processNonDigit() {
+    // It might just be a prefix that we haven't skipped. We don't want to
+    // skip them initially because they might also be semantically meaningful,
+    // e.g. leading %. So we allow them through the loop, but only once.
+    var foundAnInterpretation = false;
+    if (input.index == 0 && !prefixesSkipped) {
+      prefixesSkipped = true;
+      checkPrefixes(skip: true);
+      foundAnInterpretation = true;
+    }
+
     for (var key in replacements.keys) {
       if (input.startsWith(key)) {
         _normalized.write(replacements[key]());
@@ -804,13 +1041,8 @@
         return;
       }
     }
-    // It might just be a prefix that we haven't skipped. We don't want to
-    // skip them initially because they might also be semantically meaningful,
-    // e.g. leading %. So we allow them through the loop, but only once.
-    if (input.index == 0 && !prefixesSkipped) {
-      prefixesSkipped = true;
-      checkPrefixes(skip: true);
-    } else {
+    // We haven't found either of these things, this seems invalid.
+    if (!foundAnInterpretation) {
       done = true;
     }
   }
@@ -843,6 +1075,9 @@
   /// Parse the number portion of the input, i.e. not any prefixes or suffixes,
   /// and assuming NaN and Infinity are already handled.
   num parseNumber(_Stream input) {
+    if (gotNegative) {
+      _normalized.write('-');
+    }
     while (!done && !input.atEnd()) {
       int digit = asDigit(input.peek());
       if (digit != null) {
diff --git a/pubspec.yaml b/pubspec.yaml
index d0faf60..e774afe 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
 name: intl
-version: 0.13.0
+version: 0.13.0-dev
 author: Dart Team <misc@dartlang.org>
 description: Contains code to deal with internationalized/localized messages, date and number formatting and parsing, bi-directional text, and other internationalization issues.
 homepage: https://github.com/dart-lang/intl
diff --git a/test/number_format_test.dart b/test/number_format_test.dart
index 652cc14..d7141e5 100644
--- a/test/number_format_test.dart
+++ b/test/number_format_test.dart
@@ -215,6 +215,8 @@
     formatted = tnd.format(amount);
     expect(formatted, digitsCheck[3]);
   });
+
+  testSimpleCurrencySymbols();
 }
 
 void testAgainstIcu(locale, List<NumberFormat> testFormats, list) {
@@ -245,3 +247,38 @@
     }
   });
 }
+
+testSimpleCurrencySymbols() {
+  var currencies = ['USD', 'CAD', 'EUR', 'CRC'];
+  //  Note that these print using the simple symbol as if we were in a
+  // a locale where that currency symbol is well understood. So we
+  // expect Canadian dollars printed as $, even though our locale is
+  // en_US, and this would confuse users.
+  var simple = currencies.map((currency) =>
+      new NumberFormat.simpleCurrency(locale: 'en_US', name: currency));
+  var expectedSimple = [r'$', r'$', '\u20ac', '\u20a1'];
+  // These will always print as the global name, regardless of locale
+  var global = currencies.map(
+      (currency) => new NumberFormat.currency(locale: 'en_US', name: currency));
+  var expectedGlobal = currencies;
+
+  testCurrencySymbolsFor(expectedGlobal, global, "global");
+  testCurrencySymbolsFor(expectedSimple, simple, "simple");
+}
+
+testCurrencySymbolsFor(expected, formats, name) {
+  var amount = 1000000.32;
+  new Map.fromIterables(expected, formats)
+      .forEach((expected, NumberFormat format) {
+    test("Test $name ${format.currencyName}", () {
+      // We have to allow for currencies with different fraction digits, e.g. CRC.
+      var maxDigits = format.maximumFractionDigits;
+      var rounded = maxDigits == 0 ? amount.round() : amount;
+      var fractionDigits = (amount - rounded) < 0.00001 ? '.32' : '';
+      var formatted = format.format(rounded);
+      expect(formatted, "${expected}1,000,000$fractionDigits");
+      var parsed = format.parse(formatted);
+      expect(parsed, rounded);
+    });
+  });
+}