diff --git a/lib/codegen.ex b/lib/codegen.ex
index 134aaae..e7d49dc 100644
--- a/lib/codegen.ex
+++ b/lib/codegen.ex
@@ -48,7 +48,7 @@ defmodule Jason.Codegen do
       |> Enum.map(&encode_pair(&1, encode_args))
       |> Enum.intersperse(",")
 
-    collapse_static(List.flatten(["{", elements] ++ '}'))
+    collapse_static(List.flatten(["{", elements] ++ ~c'}'))
   end
 
   defp clauses_to_ranges([{:->, _, [[{:in, _, [byte, range]}, rest], action]} | tail], acc, env) do
@@ -116,7 +116,7 @@ defmodule Jason.Codegen do
 
   defp check_safe_key!(binary) do
     for <<(<<byte>> <- binary)>> do
-      if byte > 0x7F or byte < 0x1F or byte in '"\\/' do
+      if byte > 0x7F or byte < 0x1F or byte in ~c'"\\/' do
         raise EncodeError,
               "invalid byte #{inspect(byte, base: :hex)} in literal key: #{inspect(binary)}"
       end
diff --git a/lib/decoder.ex b/lib/decoder.ex
index 782629f..7502cf8 100644
--- a/lib/decoder.ex
+++ b/lib/decoder.ex
@@ -101,37 +101,37 @@ defmodule Jason.Decoder do
 
   defp value(data, original, skip, stack, decode) do
     bytecase data do
-      _ in '\s\n\t\r', rest ->
+      _ in ~c'\s\n\t\r', rest ->
         value(rest, original, skip + 1, stack, decode)
-      _ in '0', rest ->
+      _ in ~c'0', rest ->
         number_zero(rest, original, skip, stack, decode, 1)
-      _ in '123456789', rest ->
+      _ in ~c'123456789', rest ->
         number(rest, original, skip, stack, decode, 1)
-      _ in '-', rest ->
+      _ in ~c'-', rest ->
         number_minus(rest, original, skip, stack, decode)
-      _ in '"', rest ->
+      _ in ~c'"', rest ->
         string(rest, original, skip + 1, stack, decode, 0)
-      _ in '[', rest ->
+      _ in ~c'[', rest ->
         array(rest, original, skip + 1, stack, decode)
-      _ in '{', rest ->
+      _ in ~c'{', rest ->
         object(rest, original, skip + 1, stack, decode)
-      _ in ']', rest ->
+      _ in ~c']', rest ->
         empty_array(rest, original, skip + 1, stack, decode)
-      _ in 't', rest ->
+      _ in ~c't', rest ->
         case rest do
           <<"rue", rest::bits>> ->
             continue(rest, original, skip + 4, stack, decode, true)
           <<_::bits>> ->
             error(original, skip)
         end
-      _ in 'f', rest ->
+      _ in ~c'f', rest ->
         case rest do
           <<"alse", rest::bits>> ->
             continue(rest, original, skip + 5, stack, decode, false)
           <<_::bits>> ->
             error(original, skip)
         end
-      _ in 'n', rest ->
+      _ in ~c'n', rest ->
         case rest do
           <<"ull", rest::bits>> ->
             continue(rest, original, skip + 4, stack, decode, nil)
@@ -149,7 +149,7 @@ defmodule Jason.Decoder do
     number_zero(rest, original, skip, stack, decode, 2)
   end
   defp number_minus(<<byte, rest::bits>>, original, skip, stack, decode)
-       when byte in '123456789' do
+       when byte in ~c'123456789' do
     number(rest, original, skip, stack, decode, 2)
   end
   defp number_minus(<<_rest::bits>>, original, skip, _stack, _decode) do
@@ -164,13 +164,13 @@ defmodule Jason.Decoder do
   end
 
   defp number(<<byte, rest::bits>>, original, skip, stack, decode, len)
-       when byte in '0123456789' do
+       when byte in ~c'0123456789' do
     number(rest, original, skip, stack, decode, len + 1)
   end
   defp number(<<?., rest::bits>>, original, skip, stack, decode, len) do
     number_frac(rest, original, skip, stack, decode, len + 1)
   end
-  defp number(<<e, rest::bits>>, original, skip, stack, decode, len) when e in 'eE' do
+  defp number(<<e, rest::bits>>, original, skip, stack, decode, len) when e in ~c'eE' do
     prefix = binary_part(original, skip, len)
     number_exp_copy(rest, original, skip + len + 1, stack, decode, prefix)
   end
@@ -184,7 +184,7 @@ defmodule Jason.Decoder do
   end
 
   defp number_frac(<<byte, rest::bits>>, original, skip, stack, decode, len)
-       when byte in '0123456789' do
+       when byte in ~c'0123456789' do
     number_frac_cont(rest, original, skip, stack, decode, len + 1)
   end
   defp number_frac(<<_rest::bits>>, original, skip, _stack, _decode, len) do
@@ -192,11 +192,11 @@ defmodule Jason.Decoder do
   end
 
   defp number_frac_cont(<<byte, rest::bits>>, original, skip, stack, decode, len)
-       when byte in '0123456789' do
+       when byte in ~c'0123456789' do
     number_frac_cont(rest, original, skip, stack, decode, len + 1)
   end
   defp number_frac_cont(<<e, rest::bits>>, original, skip, stack, decode, len)
-       when e in 'eE' do
+       when e in ~c'eE' do
     number_exp(rest, original, skip, stack, decode, len + 1)
   end
   defp number_frac_cont(<<rest::bits>>, original, skip, stack, decode, len) do
@@ -207,11 +207,11 @@ defmodule Jason.Decoder do
   end
 
   defp number_exp(<<byte, rest::bits>>, original, skip, stack, decode, len)
-       when byte in '0123456789' do
+       when byte in ~c'0123456789' do
     number_exp_cont(rest, original, skip, stack, decode, len + 1)
   end
   defp number_exp(<<byte, rest::bits>>, original, skip, stack, decode, len)
-       when byte in '+-' do
+       when byte in ~c'+-' do
     number_exp_sign(rest, original, skip, stack, decode, len + 1)
   end
   defp number_exp(<<_rest::bits>>, original, skip, _stack, _decode, len) do
@@ -219,7 +219,7 @@ defmodule Jason.Decoder do
   end
 
   defp number_exp_sign(<<byte, rest::bits>>, original, skip, stack, decode, len)
-       when byte in '0123456789' do
+       when byte in ~c'0123456789' do
     number_exp_cont(rest, original, skip, stack, decode, len + 1)
   end
   defp number_exp_sign(<<_rest::bits>>, original, skip, _stack, _decode, len) do
@@ -227,7 +227,7 @@ defmodule Jason.Decoder do
   end
 
   defp number_exp_cont(<<byte, rest::bits>>, original, skip, stack, decode, len)
-       when byte in '0123456789' do
+       when byte in ~c'0123456789' do
     number_exp_cont(rest, original, skip, stack, decode, len + 1)
   end
   defp number_exp_cont(<<rest::bits>>, original, skip, stack, decode, len) do
@@ -238,11 +238,11 @@ defmodule Jason.Decoder do
   end
 
   defp number_exp_copy(<<byte, rest::bits>>, original, skip, stack, decode, prefix)
-       when byte in '0123456789' do
+       when byte in ~c'0123456789' do
     number_exp_cont(rest, original, skip, stack, decode, prefix, 1)
   end
   defp number_exp_copy(<<byte, rest::bits>>, original, skip, stack, decode, prefix)
-       when byte in '+-' do
+       when byte in ~c'+-' do
     number_exp_sign(rest, original, skip, stack, decode, prefix, 1)
   end
   defp number_exp_copy(<<_rest::bits>>, original, skip, _stack, _decode, _prefix) do
@@ -250,7 +250,7 @@ defmodule Jason.Decoder do
   end
 
   defp number_exp_sign(<<byte, rest::bits>>, original, skip, stack, decode, prefix, len)
-       when byte in '0123456789' do
+       when byte in ~c'0123456789' do
     number_exp_cont(rest, original, skip, stack, decode, prefix, len + 1)
   end
   defp number_exp_sign(<<_rest::bits>>, original, skip, _stack, _decode, _prefix, len) do
@@ -258,7 +258,7 @@ defmodule Jason.Decoder do
   end
 
   defp number_exp_cont(<<byte, rest::bits>>, original, skip, stack, decode, prefix, len)
-       when byte in '0123456789' do
+       when byte in ~c'0123456789' do
     number_exp_cont(rest, original, skip, stack, decode, prefix, len + 1)
   end
   defp number_exp_cont(<<rest::bits>>, original, skip, stack, decode, prefix, len) do
@@ -276,7 +276,7 @@ defmodule Jason.Decoder do
   defp number_zero(<<?., rest::bits>>, original, skip, stack, decode, len) do
     number_frac(rest, original, skip, stack, decode, len + 1)
   end
-  defp number_zero(<<e, rest::bits>>, original, skip, stack, decode, len) when e in 'eE' do
+  defp number_zero(<<e, rest::bits>>, original, skip, stack, decode, len) when e in ~c'eE' do
     number_exp_copy(rest, original, skip + len + 1, stack, decode, "0")
   end
   defp number_zero(<<rest::bits>>, original, skip, stack, decode, len) do
@@ -300,13 +300,13 @@ defmodule Jason.Decoder do
 
   defp array(data, original, skip, stack, decode, value) do
     bytecase data do
-      _ in '\s\n\t\r', rest ->
+      _ in ~c'\s\n\t\r', rest ->
         array(rest, original, skip + 1, stack, decode, value)
-      _ in ']', rest ->
+      _ in ~c']', rest ->
         [acc | stack] = stack
         value = :lists.reverse(acc, [value])
         continue(rest, original, skip + 1, stack, decode, value)
-      _ in ',', rest ->
+      _ in ~c',', rest ->
         [acc | stack] = stack
         value(rest, original, skip + 1, [@array, [value | acc] | stack], decode)
       _, _rest ->
@@ -324,16 +324,16 @@ defmodule Jason.Decoder do
 
   defp object(data, original, skip, stack, decode, value) do
     bytecase data do
-      _ in '\s\n\t\r', rest ->
+      _ in ~c'\s\n\t\r', rest ->
         object(rest, original, skip + 1, stack, decode, value)
-      _ in '}', rest ->
+      _ in ~c'}', rest ->
         skip = skip + 1
         [key, acc | stack] = stack
         decode(keys: key_decode) = decode
         final = [{key_decode.(key), value} | acc]
         decode(objects: object_decode) = decode
         continue(rest, original, skip, stack, decode, object_decode.(final))
-      _ in ',', rest ->
+      _ in ~c',', rest ->
         skip = skip + 1
         [key, acc | stack] = stack
         decode(keys: key_decode) = decode
@@ -348,9 +348,9 @@ defmodule Jason.Decoder do
 
   defp key(data, original, skip, stack, decode) do
     bytecase data do
-      _ in '\s\n\t\r', rest ->
+      _ in ~c'\s\n\t\r', rest ->
         key(rest, original, skip + 1, stack, decode)
-      _ in '}', rest ->
+      _ in ~c'}', rest ->
         case stack do
           [[] | stack] ->
             decode(objects: object_decode) = decode
@@ -358,7 +358,7 @@ defmodule Jason.Decoder do
           _ ->
             error(original, skip)
         end
-      _ in '"', rest ->
+      _ in ~c'"', rest ->
         string(rest, original, skip + 1, [@key | stack], decode, 0)
       _, _rest ->
         error(original, skip)
@@ -369,9 +369,9 @@ defmodule Jason.Decoder do
 
   defp key(data, original, skip, stack, decode, value) do
     bytecase data do
-      _ in '\s\n\t\r', rest ->
+      _ in ~c'\s\n\t\r', rest ->
         key(rest, original, skip + 1, stack, decode, value)
-      _ in ':', rest ->
+      _ in ~c':', rest ->
         value(rest, original, skip + 1, [@object, value | stack], decode)
       _, _rest ->
         error(original, skip)
@@ -385,11 +385,11 @@ defmodule Jason.Decoder do
   # http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
   defp string(data, original, skip, stack, decode, len) do
     bytecase data, 128 do
-      _ in '"', rest ->
+      _ in ~c'"', rest ->
         decode(strings: string_decode) = decode
         string = string_decode.(binary_part(original, skip, len))
         continue(rest, original, skip + len + 1, stack, decode, string)
-      _ in '\\', rest ->
+      _ in ~c'\\', rest ->
         part = binary_part(original, skip, len)
         escape(rest, original, skip + len, stack, decode, part)
       _ in unquote(0x00..0x1F), _rest ->
@@ -409,11 +409,11 @@ defmodule Jason.Decoder do
 
   defp string(data, original, skip, stack, decode, acc, len) do
     bytecase data, 128 do
-      _ in '"', rest ->
+      _ in ~c'"', rest ->
         last = binary_part(original, skip, len)
         string = IO.iodata_to_binary([acc | last])
         continue(rest, original, skip + len + 1, stack, decode, string)
-      _ in '\\', rest ->
+      _ in ~c'\\', rest ->
         part = binary_part(original, skip, len)
         escape(rest, original, skip + len, stack, decode, [acc | part])
       _ in unquote(0x00..0x1F), _rest ->
@@ -433,23 +433,23 @@ defmodule Jason.Decoder do
 
   defp escape(data, original, skip, stack, decode, acc) do
     bytecase data do
-      _ in 'b', rest ->
-        string(rest, original, skip + 2, stack, decode, [acc | '\b'], 0)
-      _ in 't', rest ->
-        string(rest, original, skip + 2, stack, decode, [acc | '\t'], 0)
-      _ in 'n', rest ->
-        string(rest, original, skip + 2, stack, decode, [acc | '\n'], 0)
-      _ in 'f', rest ->
-        string(rest, original, skip + 2, stack, decode, [acc | '\f'], 0)
-      _ in 'r', rest ->
-        string(rest, original, skip + 2, stack, decode, [acc | '\r'], 0)
-      _ in '"', rest ->
-        string(rest, original, skip + 2, stack, decode, [acc | '\"'], 0)
-      _ in '/', rest ->
-        string(rest, original, skip + 2, stack, decode, [acc | '/'], 0)
-      _ in '\\', rest ->
-        string(rest, original, skip + 2, stack, decode, [acc | '\\'], 0)
-      _ in 'u', rest ->
+      _ in ~c'b', rest ->
+        string(rest, original, skip + 2, stack, decode, [acc | ~c'\b'], 0)
+      _ in ~c't', rest ->
+        string(rest, original, skip + 2, stack, decode, [acc | ~c'\t'], 0)
+      _ in ~c'n', rest ->
+        string(rest, original, skip + 2, stack, decode, [acc | ~c'\n'], 0)
+      _ in ~c'f', rest ->
+        string(rest, original, skip + 2, stack, decode, [acc | ~c'\f'], 0)
+      _ in ~c'r', rest ->
+        string(rest, original, skip + 2, stack, decode, [acc | ~c'\r'], 0)
+      _ in ~c'"', rest ->
+        string(rest, original, skip + 2, stack, decode, [acc | ~c'\"'], 0)
+      _ in ~c'/', rest ->
+        string(rest, original, skip + 2, stack, decode, [acc | ~c'/'], 0)
+      _ in ~c'\\', rest ->
+        string(rest, original, skip + 2, stack, decode, [acc | ~c'\\'], 0)
+      _ in ~c'u', rest ->
         escapeu(rest, original, skip, stack, decode, acc)
       _, _rest ->
         error(original, skip + 1)
@@ -606,7 +606,7 @@ defmodule Jason.Decoder do
     end
 
     defp escapeu_surrogate_clauses(last, rest, original, skip, stack, decode, acc, hi) do
-      digits1 = 'Dd'
+      digits1 = ~c'Dd'
       digits2 = Stream.concat([?C..?F, ?c..?f])
       for {int, first} <- unicode_escapes(digits1, digits2) do
         escapeu_surrogate_clause(int, first, last, rest, original, skip, stack, decode, acc, hi)
@@ -692,7 +692,7 @@ defmodule Jason.Decoder do
   end
 
   defp terminate(<<byte, rest::bits>>, original, skip, stack, decode, value)
-       when byte in '\s\n\r\t' do
+       when byte in ~c'\s\n\r\t' do
     terminate(rest, original, skip + 1, stack, decode, value)
   end
   defp terminate(<<>>, _original, _skip, _stack, _decode, value) do
diff --git a/lib/encode.ex b/lib/encode.ex
index 3c42dcd..ffe9e1f 100644
--- a/lib/encode.ex
+++ b/lib/encode.ex
@@ -161,7 +161,7 @@ defmodule Jason.Encode do
   end
 
   defp list_loop([], _escape, _encode_map) do
-    ']'
+    ~c']'
   end
 
   defp list_loop([head | tail], escape, encode_map) do
@@ -190,7 +190,7 @@ defmodule Jason.Encode do
   end
 
   defp map_naive_loop([], _escape, _encode_map) do
-    '}'
+    ~c'}'
   end
 
   defp map_naive_loop([{key, value} | tail], escape, encode_map) do
@@ -208,7 +208,7 @@ defmodule Jason.Encode do
   end
 
   defp map_strict_loop([], _encode_map, _escape, _visited) do
-    '}'
+    ~c'}'
   end
 
   defp map_strict_loop([{key, value} | tail], escape, encode_map, visited) do
@@ -281,7 +281,7 @@ defmodule Jason.Encode do
     [?", escape.(string, string, 0), ?"]
   end
 
-  slash_escapes = Enum.zip('\b\t\n\f\r\"\\', 'btnfr"\\')
+  slash_escapes = Enum.zip(~c'\b\t\n\f\r\"\\', ~c'btnfr"\\')
   surogate_escapes = Enum.zip([0x2028, 0x2029], ["\\u2028", "\\u2029"])
   ranges = [{0x00..0x1F, :unicode} | slash_escapes]
   html_ranges = [{0x00..0x1F, :unicode}, {?<, :unicode}, {?/, ?/} | slash_escapes]
diff --git a/lib/formatter.ex b/lib/formatter.ex
index 88826eb..560a2f5 100644
--- a/lib/formatter.ex
+++ b/lib/formatter.ex
@@ -163,11 +163,11 @@ defmodule Jason.Formatter do
     cont.(tail, output_acc)
   end
 
-  defp pp_byte(byte, rest, output, depth, empty, opts) when byte in ' \n\r\t' do
+  defp pp_byte(byte, rest, output, depth, empty, opts) when byte in ~c' \n\r\t' do
     pp_iodata(rest, output, depth, empty, opts)
   end
 
-  defp pp_byte(byte, rest, output, depth, empty, opts) when byte in '{[' do
+  defp pp_byte(byte, rest, output, depth, empty, opts) when byte in ~c'{[' do
     {out, depth} =
       cond do
         depth == :first -> {byte, 1}
@@ -180,25 +180,25 @@ defmodule Jason.Formatter do
     pp_iodata(rest, [output, out], depth, empty, opts)
   end
 
-  defp pp_byte(byte, rest, output, depth, true = _empty, opts) when byte in '}]' do
+  defp pp_byte(byte, rest, output, depth, true = _empty, opts) when byte in ~c'}]' do
     empty = false
     depth = depth - 1
     pp_iodata(rest, [output, byte], depth, empty, opts)
   end
 
-  defp pp_byte(byte, rest, output, depth, false = empty, opts) when byte in '}]' do
+  defp pp_byte(byte, rest, output, depth, false = empty, opts) when byte in ~c'}]' do
     depth = depth - 1
     out = [opts(opts, :line), tab(opts(opts, :indent), depth), byte]
     pp_iodata(rest, [output, out], depth, empty, opts)
   end
 
-  defp pp_byte(byte, rest, output, depth, _empty, opts) when byte in ',' do
+  defp pp_byte(byte, rest, output, depth, _empty, opts) when byte in ~c',' do
     empty = false
     out = [byte, opts(opts, :line), tab(opts(opts, :indent), depth)]
     pp_iodata(rest, [output, out], depth, empty, opts)
   end
 
-  defp pp_byte(byte, rest, output, depth, empty, opts) when byte in ':' do
+  defp pp_byte(byte, rest, output, depth, empty, opts) when byte in ~c':' do
     out = [byte, opts(opts, :colon)]
     pp_iodata(rest, [output, out], depth, empty, opts)
   end
diff --git a/lib/sigil.ex b/lib/sigil.ex
index e5447ef..16aec39 100644
--- a/lib/sigil.ex
+++ b/lib/sigil.ex
@@ -33,7 +33,7 @@ defmodule Jason.Sigil do
       iex> ~j'{"atom": "value"}'a
       %{atom: "value"}
 
-      iex> ~j'{"#{:j}": #{'"j"'}}'A
+      iex> ~j'{"#{:j}": #{~c'"j"'}}'A
       %{j: "j"}
 
   """
diff --git a/test/encode_test.exs b/test/encode_test.exs
index f148a05..f4c0ef2 100644
--- a/test/encode_test.exs
+++ b/test/encode_test.exs
@@ -51,7 +51,7 @@ defmodule Jason.EncoderTest do
     assert to_json(%{"foo" => "bar"})  == ~s({"foo":"bar"})
     assert to_json(%{foo: :bar}) == ~s({"foo":"bar"})
     assert to_json(%{42 => :bar}) == ~s({"42":"bar"})
-    assert to_json(%{'foo' => :bar}) == ~s({"foo":"bar"})
+    assert to_json(%{~c'foo' => :bar}) == ~s({"foo":"bar"})
 
     multi_key_map = %{"foo" => "foo1", :foo => "foo2"}
     assert_raise EncodeError, "duplicate key: foo", fn ->
@@ -105,7 +105,7 @@ defmodule Jason.EncoderTest do
     assert to_json(new([{"foo", "bar"}]))  == ~s({"foo":"bar"})
     assert to_json(new([foo: :bar])) == ~s({"foo":"bar"})
     assert to_json(new([{42, :bar}])) == ~s({"42":"bar"})
-    assert to_json(new([{'foo', :bar}])) == ~s({"foo":"bar"})
+    assert to_json(new([{~c'foo', :bar}])) == ~s({"foo":"bar"})
 
     multi_key_map = new([{"foo", "foo1"}, {:foo, "foo2"}])
     assert_raise EncodeError, "duplicate key: foo", fn ->
diff --git a/test/formatter_test.exs b/test/formatter_test.exs
index 9c1fa9a..b33ad46 100644
--- a/test/formatter_test.exs
+++ b/test/formatter_test.exs
@@ -49,13 +49,13 @@ defmodule Jason.FormatterTest do
   end
 
   test "pretty_print iolist" do
-    input = [['{"a":', " 3.14159", []], [[44]], "\"b\":", '1}']
+    input = [[~c'{"a":', " 3.14159", []], [[44]], "\"b\":", ~c'1}']
     output = ~s|{\n  "a": 3.14159,\n  "b": 1\n}|
     assert(pretty_print(input) == output)
   end
 
   test "minimize iolist" do
-    input = [['{\n"a":  ', " 3.14159", []], [[44], '"'], "b\":\t", '1\n\n}']
+    input = [[~c'{\n"a":  ', " 3.14159", []], [[44], ~c'"'], "b\":\t", ~c'1\n\n}']
     output = ~s|{"a":3.14159,"b":1}|
     assert(minimize(input) == output)
   end