       console.log(ticks.map((time) -> new Date(time)))
       return ticks
 
+  class MonthsScale extends SingleIntervalScale
+    constructor: (@months) ->
+      @typical_interval = if @months.length > 1
+          (@months[1] - @months[0]) * ONE_MONTH
+        else
+          12 * ONE_MONTH
+      super(@typical_interval)
+
+    get_ticks: (data_low, data_high) ->
+      date_range_by_year = (start_time, end_time) ->
+        start_date = new Date(last_year_no_later_than(start_time))
+        
+        end_date = new Date(last_year_no_later_than(end_time))
+        end_date.setFullYear(end_date.getFullYear() + 1)
+
+        dates = []
+        date = start_date
+        while true
+          dates.push(copy_date(date))
+
+          date.setFullYear(date.getFullYear() + 1)
+          if date > end_date
+            break
+
+        return dates
+
+      year_dates = date_range_by_year(data_low, data_high)
+
+      months = @months
+      months_of_year = (year_date) ->
+        return months.map((month) ->
+          month_date = copy_date(year_date)
+          month_date.setMonth(month)
+          return month_date)
+
+      # FIXME Use a list comprehension?
+      month_dates = _.flatten(year_dates.map((date) -> months_of_year(date)))
+
+      all_ticks = _.invoke(month_dates, 'getTime')
+      ticks_in_range = _.filter(all_ticks,
+                                ((tick) -> data_low <= tick <= data_high))
+
+      return ticks_in_range
+
   class DaysScale extends SingleIntervalScale
     constructor: (@days) ->
       @typical_interval = if @days.length > 1

    new DaysScale([1, 8, 15, 22]),
    new DaysScale([1, 15]),
    new DaysScale([1]),

    # Catchall for large timescales.
    new AdaptiveScale([1.0, 2.0, 5.0], 10.0, 10 * ONE_DAY, Infinity),
  ])

  auto_interval_temp = (data_low, data_high) ->

      # FIXME Use a list comprehension?
      day_dates = _.flatten(month_dates.map((date) -> days_of_month(date)))

      all_ticks = _.invoke(day_dates, 'getTime')
      # FIXME Since the ticks are sorted, this could be done more efficiently.
      ticks_in_range = _.filter(all_ticks,
                                ((tick) -> data_low <= tick <= data_high))

      # FIXME Continue here:
      # Transition between 12-hour and 24-hour resolutions is not correct.
      # This is because the day resolutions are aligned with the local time
      # zone, and the resolutions below are aligned with GMT.

      return ticks_in_range

