diff --git a/core/CCError.mli b/core/CCError.mli
index 4181ed55..3fefdcb3 100644
--- a/core/CCError.mli
+++ b/core/CCError.mli
@@ -48,7 +48,7 @@ val of_exn : exn -> 'a t
 val fail_printf : ('a, Buffer.t, unit, 'a t) format4 -> 'a
 (** [fail_printf format] uses [format] to obtain an error message
     and then returns [`Error msg]
-    @since NEXT_VERSION *)
+    @since 0.3.3 *)
 
 val map : ('a -> 'b) -> 'a t -> 'b t
 
diff --git a/core/CCIO.mli b/core/CCIO.mli
index a31c42cb..d7950385 100644
--- a/core/CCIO.mli
+++ b/core/CCIO.mli
@@ -29,7 +29,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 A simple abstraction over blocking IO, with strict evaluation. This is in
 no way an alternative to Lwt/Async if you need concurrency.
 
-@since NEXT_RELEASE
+@since 0.3.3
 *)
 
 (**
diff --git a/core/CCKList.mli b/core/CCKList.mli
index 003a5892..2a268103 100644
--- a/core/CCKList.mli
+++ b/core/CCKList.mli
@@ -50,11 +50,11 @@ val singleton : 'a -> 'a t
 val repeat : ?n:int -> 'a -> 'a t
 (** [repeat ~n x] repeats [x] [n] times then stops. If [n] is omitted,
     then [x] is repeated forever.
-    @since NEXT_RELEASE *)
+    @since 0.3.3 *)
 
 val cycle : 'a t -> 'a t
 (** Cycle through the iterator infinitely. The iterator shouldn't be empty.
-    @since NEXT_RELEASE *)
+    @since 0.3.3 *)
 
 
 val is_empty : 'a t -> bool
@@ -91,23 +91,23 @@ val append : 'a t -> 'a t -> 'a t
 val product_with : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
 (** Fair product of two (possibly infinite) lists into a new list. Lazy.
     The first parameter is used to combine each pair of elements
-    @since NEXT_RELEASE *)
+    @since 0.3.3 *)
 
 val product : 'a t -> 'b t -> ('a * 'b) t
 (** Specialization of {!product_with} producing tuples
-    @since NEXT_RELEASE *)
+    @since 0.3.3 *)
 
 val group : 'a equal -> 'a t -> 'a t t
 (** [group eq l] groups together consecutive elements that satisfy [eq]. Lazy.
     For instance [group (=) [1;1;1;2;2;3;3;1]] yields
       [[1;1;1]; [2;2]; [3;3]; [1]]
-    @since NEXT_RELEASE *)
+    @since 0.3.3 *)
 
 val uniq : 'a equal -> 'a t -> 'a t
 (** [uniq eq l] returns [l] but removes consecutive duplicates. Lazy.
     In other words, if several values that are equal follow one another,
     only the first of them is kept.
-    @since NEXT_RELEASE *)
+    @since 0.3.3 *)
 
 val flat_map : ('a -> 'b t) -> 'a t -> 'b t
 
@@ -140,15 +140,15 @@ val merge : 'a ord -> 'a t -> 'a t -> 'a t
 val sort : ?cmp:'a ord -> 'a t -> 'a t
 (** Eager sort. Requires the iterator to be finite. O(n ln(n)) time
     and space.
-    @since NEXT_RELEASE *)
+    @since 0.3.3 *)
 
 val sort_uniq : ?cmp:'a ord -> 'a t -> 'a t
 (** Eager sort that removes duplicate values. Requires the iterator to be
     finite. O(n ln(n)) time and space.
-    @since NEXT_RELEASE *)
+    @since 0.3.3 *)
 
 (** {2 Implementations}
-    @since NEXT_RELEASE *)
+    @since 0.3.3 *)
 
 val return : 'a -> 'a t
 val pure : 'a -> 'a t
diff --git a/core/CCList.mli b/core/CCList.mli
index 2c885a51..bd3c0ad7 100644
--- a/core/CCList.mli
+++ b/core/CCList.mli
@@ -226,7 +226,7 @@ module Zipper : sig
 end
 
 (** {2 References on Lists}
-@since NEXT_RELEASE *)
+@since 0.3.3 *)
 
 module Ref : sig
   type 'a t = 'a list ref
diff --git a/core/CCMultiMap.mli b/core/CCMultiMap.mli
index 238eb7fb..bf6e8d4b 100644
--- a/core/CCMultiMap.mli
+++ b/core/CCMultiMap.mli
@@ -109,7 +109,7 @@ module Make(K : OrderedType)(V : OrderedType) : S with type key = K.t and type v
 Represents n-to-n mappings between two types. Each element from the "left"
 is mapped to several right values, and conversely.
 
-@since NEXT_RELEASE *)
+@since 0.3.3 *)
 
 module type BIDIR = sig
   type t
diff --git a/core/CCPair.mli b/core/CCPair.mli
index ba532242..1e6ddaf3 100644
--- a/core/CCPair.mli
+++ b/core/CCPair.mli
@@ -38,11 +38,11 @@ val map_same : ('a -> 'b) -> ('a*'a) -> ('b*'b)
 
 val map_fst : ('a -> 'b) -> ('a * _) -> 'b
 (** Compose the given function with [fst].
-    @since NEXT_RELEASE *)
+    @since 0.3.3 *)
 
 val map_snd : ('a -> 'b) -> (_ * 'a) -> 'b
 (** Compose the given function with [snd].
-    @since NEXT_RELEASE *)
+    @since 0.3.3 *)
 
 val iter : ('a -> 'b -> unit) -> ('a * 'b) -> unit
 
@@ -67,16 +67,16 @@ val merge : ('a -> 'b -> 'c) -> ('a * 'b) -> 'c
 
 val fold : ('a -> 'b -> 'c) -> ('a * 'b) -> 'c
 (** Synonym to {!merge}
-    @since NEXT_RELEASE *)
+    @since 0.3.3 *)
 
 val dup : 'a -> ('a * 'a)
 (** [dup x = (x,x)] (duplicate the value)
-    @since NEXT_RELEASE *)
+    @since 0.3.3 *)
 
 val dup_map : ('a -> 'b) -> 'a -> ('a * 'b)
 (** [dup_map f x = (x, f x)]. Duplicates the value and applies the function
     to the second copy.
-    @since NEXT_RELEASE *)
+    @since 0.3.3 *)
 
 val equal : ('a -> 'a -> bool) -> ('b -> 'b -> bool) -> ('a * 'b) -> ('a * 'b) -> bool
 
diff --git a/core/CCString.mli b/core/CCString.mli
index 547ed083..f003b908 100644
--- a/core/CCString.mli
+++ b/core/CCString.mli
@@ -64,7 +64,7 @@ val hash : t -> int
 
 val init : int -> (int -> char) -> t
 (** Analog to [Array.init].
-    @since NEXT_VERSION *)
+    @since 0.3.3 *)
 
 val of_gen : char gen -> t
 val of_seq : char sequence -> t