diff --git a/.gitmodules b/.gitmodules
index e5266cfc..6acba23c 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,18 +1,12 @@
 [submodule "third_party/gtest"]
 	path = third_party/gtest
 	url = https://github.com/google/googletest
-[submodule "third_party/fmt"]
-	path = third_party/fmt
-	url = https://github.com/fmtlib/fmt
-[submodule "third_party/span-lite"]
-	path = third_party/span-lite
-	url = https://github.com/martinmoene/span-lite
-[submodule "third_party/parallel-hashmap"]
-	path = third_party/parallel-hashmap
-	url = https://github.com/greg7mdp/parallel-hashmap
 [submodule "third_party/gdtoa"]
 	path = third_party/gdtoa
 	url = https://github.com/jwiegley/gdtoa
 [submodule "third_party/testsuite"]
 	path = third_party/testsuite
 	url = https://github.com/WebAssembly/testsuite
+[submodule "third_party/abseil"]
+	path = third_party/abseil
+	url = https://github.com/abseil/abseil-cpp
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9cf4b0ee..ef2206b3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -34,7 +34,6 @@ else ()
   set(warning_flags -W3)
 endif ()
 
-
 add_subdirectory(src/base)
 add_subdirectory(src/binary)
 add_subdirectory(src/valid)
diff --git a/include/wasp/base/absl_hash_value_macros.h b/include/wasp/base/absl_hash_value_macros.h
new file mode 100644
index 00000000..ef03840d
--- /dev/null
+++ b/include/wasp/base/absl_hash_value_macros.h
@@ -0,0 +1,65 @@
+//
+// Copyright 2020 WebAssembly Community Group participants
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef WASP_BASE_ABSL_HASH_VALUE_MACROS_H_
+#define WASP_BASE_ABSL_HASH_VALUE_MACROS_H_
+
+#define WASP_ABSL_HASH_VALUE_VARGS(Name, Count, ...) \
+  WASP_ABSL_HASH_VALUE_##Count(Name, __VA_ARGS__)
+
+#define WASP_ABSL_HASH_VALUE_0(Name, ...)     \
+  template <typename H>                       \
+  H AbslHashValue(H h, const ::wasp::Name&) { \
+    return h;                                 \
+  }
+
+#define WASP_ABSL_HASH_VALUE_1(Name, f1)        \
+  template <typename H>                         \
+  H AbslHashValue(H h, const ::wasp::Name& v) { \
+    return H::combine(std::move(h), v.f1);      \
+  }
+
+#define WASP_ABSL_HASH_VALUE_2(Name, f1, f2)     \
+  template <typename H>                          \
+  H AbslHashValue(H h, const ::wasp::Name& v) {  \
+    return H::combine(std::move(h), v.f1, v.f2); \
+  }
+
+#define WASP_ABSL_HASH_VALUE_3(Name, f1, f2, f3)       \
+  template <typename H>                                \
+  H AbslHashValue(H h, const ::wasp::Name& v) {        \
+    return H::combine(std::move(h), v.f1, v.f2, v.f3); \
+  }
+
+#define WASP_ABSL_HASH_VALUE_4(Name, f1, f2, f3, f4)         \
+  template <typename H>                                      \
+  H AbslHashValue(H h, const ::wasp::Name& v) {              \
+    return H::combine(std::move(h), v.f1, v.f2, v.f3, v.f4); \
+  }
+
+#define WASP_ABSL_HASH_VALUE_5(Name, f1, f2, f3, f4, f5)           \
+  template <typename H>                                            \
+  H AbslHashValue(H h, const ::wasp::Name& v) {                    \
+    return H::combine(std::move(h), v.f1, v.f2, v.f3, v.f4, v.f5); \
+  }
+
+#define WASP_ABSL_HASH_VALUE_CONTAINER(Name)    \
+  template <typename H>                         \
+  H AbslHashValue(H h, const ::wasp::Name& v) { \
+    return H::combine(std::move(h), v);         \
+  }
+
+#endif  // WASP_BASE_ABSL_HASH_VALUE_MACROS_H_
diff --git a/include/wasp/base/features.h b/include/wasp/base/features.h
index f9af48f5..d38e2fbc 100644
--- a/include/wasp/base/features.h
+++ b/include/wasp/base/features.h
@@ -17,8 +17,7 @@
 #ifndef WASP_BASE_FEATURES_H_
 #define WASP_BASE_FEATURES_H_
 
-#include <functional>  // for std::hash
-
+#include "wasp/base/hash.h"
 #include "wasp/base/types.h"
 
 namespace wasp {
@@ -73,6 +72,11 @@ class Features {
   friend bool operator==(const Features& lhs, const Features& rhs);
   friend bool operator!=(const Features& lhs, const Features& rhs);
 
+  template <typename H>
+  friend H AbslHashValue(H h, const Features& f) {
+    return H::combine(std::move(h), f.bits_);
+  }
+
  private:
   void UpdateDependencies();
 
@@ -82,11 +86,4 @@ class Features {
 
 }  // namespace wasp
 
-namespace std {
-template <>
-struct hash<::wasp::Features> {
-  size_t operator()(const ::wasp::Features&) const;
-};
-}  // namespace std
-
 #endif  // WASP_BASE_FEATURES_H_
diff --git a/include/wasp/base/formatters-inl.h b/include/wasp/base/formatters-inl.h
index 8d815e6d..7211a057 100644
--- a/include/wasp/base/formatters-inl.h
+++ b/include/wasp/base/formatters-inl.h
@@ -71,7 +71,7 @@ std::ostream& operator<<(std::ostream& os, const ::std::array<T, N>& self) {
 
 template <typename T>
 std::ostream& operator<<(std::ostream& os, const ::std::vector<T>& self) {
-  return os << ::wasp::span{self};
+  return os << ::wasp::MakeSpan(self);
 }
 
 template <typename... Ts>
diff --git a/include/wasp/base/hash.h b/include/wasp/base/hash.h
index 702a1271..34ed7798 100644
--- a/include/wasp/base/hash.h
+++ b/include/wasp/base/hash.h
@@ -19,25 +19,11 @@
 
 #include <iterator>
 
-#include "parallel_hashmap/phmap_utils.h"
+#include "absl/hash/hash.h"
 
 namespace wasp {
 
-using phmap::HashState;
-
-template <typename T1, typename T2>
-size_t HashRange(T1 begin, T2 end) {
-  size_t state = 0;
-  for (auto it = begin; it != end; ++it) {
-    state = HashState::combine(state, *it);
-  }
-  return state;
-}
-
-template <typename C>
-size_t HashContainer(const C& c) {
-  return HashRange(std::begin(c), std::end(c));
-}
+using absl::HashState;
 
 }  // namespace wasp
 
diff --git a/include/wasp/base/hashmap.h b/include/wasp/base/hashmap.h
index efd4dfa9..dcfb1b18 100644
--- a/include/wasp/base/hashmap.h
+++ b/include/wasp/base/hashmap.h
@@ -17,14 +17,17 @@
 #ifndef WASP_BASE_HASHMAP_H_
 #define WASP_BASE_HASHMAP_H_
 
-#include "parallel_hashmap/phmap.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/container/node_hash_map.h"
+#include "absl/container/node_hash_set.h"
 
 namespace wasp {
 
-using phmap::flat_hash_map;
-using phmap::flat_hash_set;
-using phmap::node_hash_map;
-using phmap::node_hash_set;
+using absl::flat_hash_map;
+using absl::flat_hash_set;
+using absl::node_hash_map;
+using absl::node_hash_set;
 
 }  // namespace wasp
 
diff --git a/include/wasp/base/span.h b/include/wasp/base/span.h
index 0dd7d1c5..ab7af8f9 100644
--- a/include/wasp/base/span.h
+++ b/include/wasp/base/span.h
@@ -21,29 +21,25 @@
 
 #include <functional>
 
-#include "nonstd/span.hpp"
+#include "absl/types/span.h"
 #include "wasp/base/string_view.h"
 #include "wasp/base/types.h"
 
 namespace wasp {
 
-using nonstd::span;
+template <typename T>
+using span = absl::Span<T>;
 
-using nonstd::operator==;
-using nonstd::operator!=;
-using nonstd::operator<;
-using nonstd::operator<=;
-using nonstd::operator>;
-using nonstd::operator>=;
+using absl::operator==;
+using absl::operator!=;
+using absl::operator<;
+using absl::operator<=;
+using absl::operator>;
+using absl::operator>=;
 
-using span_extent_t = nonstd::span_lite::extent_t;
+using absl::MakeSpan;
 
-constexpr span_extent_t dynamic_extent = -1;
-
-template <class T, span_extent_t Extent>
-void remove_prefix(span<T, Extent>* s, span_extent_t offset) {
-  *s = s->subspan(offset);
-}
+using span_extent_t = size_t;
 
 using SpanU8 = span<const u8>;
 using Location = SpanU8;
@@ -61,13 +57,4 @@ inline string_view ToStringView(SpanU8 span) {
 
 }  // namespace wasp
 
-namespace std {
-
-template <>
-struct hash<::wasp::SpanU8> {
-  size_t operator()(::wasp::SpanU8) const;
-};
-
-}
-
 #endif  // WASP_BASE_SPAN_H_
diff --git a/include/wasp/base/std_hash_macros.h b/include/wasp/base/std_hash_macros.h
deleted file mode 100644
index 45130f9d..00000000
--- a/include/wasp/base/std_hash_macros.h
+++ /dev/null
@@ -1,80 +0,0 @@
-//
-// Copyright 2019 WebAssembly Community Group participants
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef WASP_BASE_STD_HASH_MACROS_H_
-#define WASP_BASE_STD_HASH_MACROS_H_
-
-#define WASP_DECLARE_STD_HASH(Name, ...)          \
-  namespace std {                                 \
-  template <>                                     \
-  struct hash<::wasp::Name> {                     \
-    size_t operator()(const ::wasp::Name&) const; \
-  };                                              \
-  }
-
-#define WASP_STD_HASH_VARGS(Name, Count, ...) \
-  WASP_STD_HASH_##Count(Name, __VA_ARGS__)
-
-#define WASP_STD_HASH_0(Name, ...)                                     \
-  namespace std {                                                      \
-  size_t hash<::wasp::Name>::operator()(const ::wasp::Name& v) const { \
-    return 0;                                                          \
-  }                                                                    \
-  }
-
-#define WASP_STD_HASH_1(Name, f1)                                      \
-  namespace std {                                                      \
-  size_t hash<::wasp::Name>::operator()(const ::wasp::Name& v) const { \
-    return ::wasp::HashState::combine(0, v.f1);                        \
-  }                                                                    \
-  }
-
-#define WASP_STD_HASH_2(Name, f1, f2)                                  \
-  namespace std {                                                      \
-  size_t hash<::wasp::Name>::operator()(const ::wasp::Name& v) const { \
-    return ::wasp::HashState::combine(0, v.f1, v.f2);                  \
-  }                                                                    \
-  }
-
-#define WASP_STD_HASH_3(Name, f1, f2, f3)                              \
-  namespace std {                                                      \
-  size_t hash<::wasp::Name>::operator()(const ::wasp::Name& v) const { \
-    return ::wasp::HashState::combine(0, v.f1, v.f2, v.f3);            \
-  }                                                                    \
-  }
-
-#define WASP_STD_HASH_4(Name, f1, f2, f3, f4)                          \
-  namespace std {                                                      \
-  size_t hash<::wasp::Name>::operator()(const ::wasp::Name& v) const { \
-    return ::wasp::HashState::combine(0, v.f1, v.f2, v.f3, v.f4);      \
-  }                                                                    \
-  }
-
-#define WASP_STD_HASH_5(Name, f1, f2, f3, f4, f5)                       \
-  namespace std {                                                       \
-  size_t hash<::wasp::Name>::operator()(const ::wasp::Name& v) const {  \
-    return ::wasp::HashState::combine(0, v.f1, v.f2, v.f3, v.f4, v.f5); \
-  }                                                                     \
-  }
-
-#define WASP_STD_HASH_CONTAINER(Name)                                  \
-  namespace std {                                                      \
-  size_t hash<::wasp::Name>::operator()(const ::wasp::Name& v) const { \
-    return ::wasp::HashContainer(v);                                   \
-  }                                                                    \
-  }
-
-#endif  // WASP_BASE_STD_HASH_MACROS_H_
diff --git a/include/wasp/base/v128.h b/include/wasp/base/v128.h
index cb8fc3b3..7d76c4d6 100644
--- a/include/wasp/base/v128.h
+++ b/include/wasp/base/v128.h
@@ -81,21 +81,18 @@ class v128 {
   friend bool operator==(const v128&, const v128&);
   friend bool operator!=(const v128&, const v128&);
 
+  template <typename H>
+  friend H AbslHashValue(H h, const v128& f) {
+    auto u = f.as<::wasp::u64x2>();
+    return H::combine(std::move(h), u[0], u[1]);
+  }
+
  private:
   u8x16 data_;
 };
 
 }  // namespace wasp
 
-namespace std {
-
-template <>
-struct hash<::wasp::v128> {
-  size_t operator()(const ::wasp::v128&) const;
-};
-
-}  // namespace std
-
 #include "wasp/base/v128-inl.h"
 
 #endif  // WASP_BASE_V128_H_
diff --git a/include/wasp/base/wasm_types.h b/include/wasp/base/wasm_types.h
index e7663d0d..883a8ac2 100644
--- a/include/wasp/base/wasm_types.h
+++ b/include/wasp/base/wasm_types.h
@@ -20,9 +20,9 @@
 #include <iosfwd>
 #include <vector>
 
+#include "wasp/base/absl_hash_value_macros.h"
 #include "wasp/base/at.h"
 #include "wasp/base/operator_eq_ne_macros.h"
-#include "wasp/base/std_hash_macros.h"
 #include "wasp/base/types.h"
 
 namespace wasp {
@@ -144,9 +144,9 @@ using ShuffleImmediate = std::array<u8, 16>;
 WASP_BASE_WASM_STRUCTS(WASP_DECLARE_OPERATOR_EQ_NE)
 WASP_BASE_WASM_CONTAINERS(WASP_DECLARE_OPERATOR_EQ_NE)
 
-}  // namespace wasp
+WASP_BASE_WASM_STRUCTS(WASP_ABSL_HASH_VALUE_VARGS)
+WASP_BASE_WASM_CONTAINERS(WASP_ABSL_HASH_VALUE_CONTAINER)
 
-WASP_BASE_WASM_STRUCTS(WASP_DECLARE_STD_HASH)
-WASP_BASE_WASM_CONTAINERS(WASP_DECLARE_STD_HASH)
+}  // namespace wasp
 
 #endif // WASP_BASE_WASM_TYPES_H_
diff --git a/include/wasp/binary/lazy_sequence-inl.h b/include/wasp/binary/lazy_sequence-inl.h
index 415a3709..b5590aeb 100644
--- a/include/wasp/binary/lazy_sequence-inl.h
+++ b/include/wasp/binary/lazy_sequence-inl.h
@@ -27,7 +27,7 @@ void LazySequence<T>::NotifyRead(const u8* pos, bool ok) {
     } else if (expected_count_ && count_ != *expected_count_) {
       // Reached the end, but there was a mismatch.
       LazySequenceBase::OnCountError(context_.errors,
-                                     SpanU8{last_pos_, data_.end()}, name_,
+                                     MakeSpan(last_pos_, data_.end()), name_,
                                      *expected_count_, count_);
     }
   }
diff --git a/include/wasp/binary/linking_section/types.h b/include/wasp/binary/linking_section/types.h
index 1969affd..ad71e2a3 100644
--- a/include/wasp/binary/linking_section/types.h
+++ b/include/wasp/binary/linking_section/types.h
@@ -19,11 +19,11 @@
 
 #include <vector>
 
+#include "wasp/base/absl_hash_value_macros.h"
 #include "wasp/base/at.h"
 #include "wasp/base/operator_eq_ne_macros.h"
 #include "wasp/base/optional.h"
 #include "wasp/base/span.h"
-#include "wasp/base/std_hash_macros.h"
 #include "wasp/base/string_view.h"
 #include "wasp/base/types.h"
 #include "wasp/base/variant.h"
@@ -196,9 +196,9 @@ struct SymbolInfo {
 WASP_BINARY_LINKING_STRUCTS(WASP_DECLARE_OPERATOR_EQ_NE)
 WASP_BINARY_LINKING_CONTAINERS(WASP_DECLARE_OPERATOR_EQ_NE)
 
-}  // namespace wasp::binary
+WASP_BINARY_LINKING_STRUCTS(WASP_ABSL_HASH_VALUE_VARGS)
+WASP_BINARY_LINKING_CONTAINERS(WASP_ABSL_HASH_VALUE_CONTAINER)
 
-WASP_BINARY_LINKING_STRUCTS(WASP_DECLARE_STD_HASH)
-WASP_BINARY_LINKING_CONTAINERS(WASP_DECLARE_STD_HASH)
+}  // namespace wasp::binary
 
 #endif // WASP_BINARY_LINKING_SECTION_TYPES_H_
diff --git a/include/wasp/binary/name_section/types.h b/include/wasp/binary/name_section/types.h
index b58334ca..2e8ef146 100644
--- a/include/wasp/binary/name_section/types.h
+++ b/include/wasp/binary/name_section/types.h
@@ -19,10 +19,10 @@
 
 #include <vector>
 
+#include "wasp/base/absl_hash_value_macros.h"
 #include "wasp/base/at.h"
 #include "wasp/base/operator_eq_ne_macros.h"
 #include "wasp/base/span.h"
-#include "wasp/base/std_hash_macros.h"
 #include "wasp/base/string_view.h"
 #include "wasp/base/types.h"
 
@@ -65,9 +65,9 @@ struct IndirectNameAssoc {
 WASP_BINARY_NAME_STRUCTS(WASP_DECLARE_OPERATOR_EQ_NE)
 WASP_BINARY_NAME_CONTAINERS(WASP_DECLARE_OPERATOR_EQ_NE)
 
-}  // namespace wasp::binary
+WASP_BINARY_NAME_STRUCTS(WASP_ABSL_HASH_VALUE_VARGS)
+WASP_BINARY_NAME_CONTAINERS(WASP_ABSL_HASH_VALUE_CONTAINER)
 
-WASP_BINARY_NAME_STRUCTS(WASP_DECLARE_STD_HASH)
-WASP_BINARY_NAME_CONTAINERS(WASP_DECLARE_STD_HASH)
+}  // namespace wasp::binary
 
 #endif // WASP_BINARY_NAME_SECTION_TYPES_H_
diff --git a/include/wasp/binary/read/location_guard.h b/include/wasp/binary/read/location_guard.h
index a6f06b05..3e4964c0 100644
--- a/include/wasp/binary/read/location_guard.h
+++ b/include/wasp/binary/read/location_guard.h
@@ -26,7 +26,7 @@ class LocationGuard {
  public:
   explicit LocationGuard(SpanU8* data) : start_{data->begin()} {}
 
-  Location range(SpanU8* end) const { return Location{start_, end->begin()}; }
+  Location range(SpanU8* end) const { return MakeSpan(start_, end->begin()); }
 
  private:
   const u8* start_;
diff --git a/include/wasp/binary/types.h b/include/wasp/binary/types.h
index 97a45a68..0dfc79aa 100644
--- a/include/wasp/binary/types.h
+++ b/include/wasp/binary/types.h
@@ -21,11 +21,11 @@
 #include <iosfwd>
 #include <vector>
 
+#include "wasp/base/absl_hash_value_macros.h"
 #include "wasp/base/at.h"
 #include "wasp/base/operator_eq_ne_macros.h"
 #include "wasp/base/optional.h"
 #include "wasp/base/span.h"
-#include "wasp/base/std_hash_macros.h"
 #include "wasp/base/string_view.h"
 #include "wasp/base/types.h"
 #include "wasp/base/v128.h"
@@ -763,9 +763,9 @@ WASP_BINARY_CONTAINERS(WASP_DECLARE_OPERATOR_EQ_NE)
 
 WASP_DECLARE_OPERATOR_EQ_NE(binary::Module)
 
-}  // namespace wasp::binary
+WASP_BINARY_STRUCTS_CUSTOM_FORMAT(WASP_ABSL_HASH_VALUE_VARGS)
+WASP_BINARY_CONTAINERS(WASP_ABSL_HASH_VALUE_CONTAINER)
 
-WASP_BINARY_STRUCTS_CUSTOM_FORMAT(WASP_DECLARE_STD_HASH)
-WASP_BINARY_CONTAINERS(WASP_DECLARE_STD_HASH)
+}  // namespace wasp::binary
 
 #endif // WASP_BINARY_TYPES_H_
diff --git a/include/wasp/text/numeric-inl.h b/include/wasp/text/numeric-inl.h
index 6abab963..6eaefe53 100644
--- a/include/wasp/text/numeric-inl.h
+++ b/include/wasp/text/numeric-inl.h
@@ -91,7 +91,7 @@ auto StrToNat(LiteralInfo info, SpanU8 span) -> optional<T> {
 
 inline void RemoveSign(SpanU8& span, Sign sign) {
   if (sign != Sign::None) {
-    remove_prefix(&span, 1);  // Remove + or -.
+    span.remove_prefix(1);  // Remove + or -.
   }
 }
 
diff --git a/include/wasp/text/read/location_guard.h b/include/wasp/text/read/location_guard.h
index 7f89c9a8..b3b2bc3c 100644
--- a/include/wasp/text/read/location_guard.h
+++ b/include/wasp/text/read/location_guard.h
@@ -28,7 +28,7 @@ class LocationGuard {
 
   Location loc() const {
     auto* end = tokenizer_.Previous().loc.end();
-    return Location{start_, start_ <= end ? end : start_};
+    return MakeSpan(start_, start_ <= end ? end : start_);
   }
 
  private:
diff --git a/include/wasp/text/types.h b/include/wasp/text/types.h
index 5908d3d9..2bfa0065 100644
--- a/include/wasp/text/types.h
+++ b/include/wasp/text/types.h
@@ -20,10 +20,10 @@
 #include <iosfwd>
 #include <utility>
 
+#include "wasp/base/absl_hash_value_macros.h"
 #include "wasp/base/at.h"
 #include "wasp/base/operator_eq_ne_macros.h"
 #include "wasp/base/optional.h"
-#include "wasp/base/std_hash_macros.h"
 #include "wasp/base/string_view.h"
 #include "wasp/base/v128.h"
 #include "wasp/base/variant.h"
@@ -1112,10 +1112,10 @@ bool operator==(const ValueTypeList& lhs, const BoundValueTypeList& rhs);
 bool operator!=(const BoundValueTypeList& lhs, const ValueTypeList& rhs);
 bool operator!=(const ValueTypeList& lhs, const BoundValueTypeList& rhs);
 
-}  // namespace wasp::text
+WASP_TEXT_STRUCTS(WASP_ABSL_HASH_VALUE_VARGS)
+WASP_TEXT_STRUCTS_CUSTOM_FORMAT(WASP_ABSL_HASH_VALUE_VARGS)
+WASP_TEXT_CONTAINERS(WASP_ABSL_HASH_VALUE_CONTAINER)
 
-WASP_TEXT_STRUCTS(WASP_DECLARE_STD_HASH)
-WASP_TEXT_STRUCTS_CUSTOM_FORMAT(WASP_DECLARE_STD_HASH)
-WASP_TEXT_CONTAINERS(WASP_DECLARE_STD_HASH)
+}  // namespace wasp::text
 
 #endif  // WASP_TEXT_TYPES_H_
diff --git a/include/wasp/valid/types.h b/include/wasp/valid/types.h
index 1c5d984a..1c1ba4e5 100644
--- a/include/wasp/valid/types.h
+++ b/include/wasp/valid/types.h
@@ -98,9 +98,9 @@ auto AsNonNullableType(StackType) -> StackType;
 WASP_VALID_STRUCTS_CUSTOM_FORMAT(WASP_DECLARE_OPERATOR_EQ_NE)
 WASP_VALID_CONTAINERS(WASP_DECLARE_OPERATOR_EQ_NE)
 
-}  // namespace wasp::valid
+WASP_VALID_STRUCTS_CUSTOM_FORMAT(WASP_ABSL_HASH_VALUE_VARGS)
+WASP_VALID_CONTAINERS(WASP_ABSL_HASH_VALUE_CONTAINER)
 
-WASP_VALID_STRUCTS_CUSTOM_FORMAT(WASP_DECLARE_STD_HASH)
-WASP_VALID_CONTAINERS(WASP_DECLARE_STD_HASH)
+}  // namespace wasp::valid
 
 #endif // WASP_VALID_TYPES_H_
diff --git a/src/base/CMakeLists.txt b/src/base/CMakeLists.txt
index 16e0761e..7d936197 100644
--- a/src/base/CMakeLists.txt
+++ b/src/base/CMakeLists.txt
@@ -15,6 +15,7 @@
 #
 
 add_library(libwasp_base
+  ../../include/wasp/base/absl_hash_value_macros.h
   ../../include/wasp/base/at.h
   ../../include/wasp/base/bitcast.h
   ../../include/wasp/base/buffer.h
@@ -36,7 +37,6 @@ add_library(libwasp_base
   ../../include/wasp/base/operator_eq_ne_macros.h
   ../../include/wasp/base/optional.h
   ../../include/wasp/base/span.h
-  ../../include/wasp/base/std_hash_macros.h
   ../../include/wasp/base/str_to_u32.h
   ../../include/wasp/base/string_view.h
   ../../include/wasp/base/types.h
@@ -65,6 +65,10 @@ target_compile_options(libwasp_base
 target_include_directories(libwasp_base
   PUBLIC
   ${wasp_SOURCE_DIR}/include
-  ${wasp_SOURCE_DIR}/third_party/span-lite/include
-  ${wasp_SOURCE_DIR}/third_party/parallel-hashmap
+)
+
+target_link_libraries(libwasp_base
+  absl::base
+  absl::container
+  absl::hash
 )
diff --git a/src/base/features.cc b/src/base/features.cc
index a1289129..f1f4c7a8 100644
--- a/src/base/features.cc
+++ b/src/base/features.cc
@@ -17,7 +17,6 @@
 #include "wasp/base/features.h"
 
 #include "wasp/base/hash.h"
-#include "wasp/base/std_hash_macros.h"
 
 namespace wasp {
 
@@ -59,9 +58,3 @@ bool operator!=(const Features& lhs, const Features& rhs) {
 }
 
 }  // namespace wasp
-
-namespace std {
-size_t hash<::wasp::Features>::operator()(const ::wasp::Features& v) const {
-  return ::wasp::HashState::combine(0, v.bits());
-}
-}  // namespace std
diff --git a/src/base/span.cc b/src/base/span.cc
index e74cd286..aec00f94 100644
--- a/src/base/span.cc
+++ b/src/base/span.cc
@@ -17,11 +17,3 @@
 #include "wasp/base/span.h"
 
 #include "wasp/base/hash.h"
-
-namespace std {
-
-size_t hash<::wasp::SpanU8>::operator()(::wasp::SpanU8 v) const {
-  return ::wasp::HashContainer(v);
-}
-
-}  // namespace std
diff --git a/src/base/v128.cc b/src/base/v128.cc
index 36dd59b2..8d4b88bf 100644
--- a/src/base/v128.cc
+++ b/src/base/v128.cc
@@ -134,12 +134,3 @@ v128::v128(u8x16 other) {
 WASP_OPERATOR_EQ_NE_1(v128, data_)
 
 }  // namespace wasp
-
-namespace std {
-
-size_t hash<::wasp::v128>::operator()(const ::wasp::v128& v) const {
-  auto u = v.as<::wasp::u64x2>();
-  return ::wasp::HashState::combine(0, u[0], u[1]);
-}
-
-}  // namespace std
diff --git a/src/base/wasm_types.cc b/src/base/wasm_types.cc
index 3dc29fc4..ca018171 100644
--- a/src/base/wasm_types.cc
+++ b/src/base/wasm_types.cc
@@ -18,7 +18,6 @@
 
 #include "wasp/base/hash.h"
 #include "wasp/base/operator_eq_ne_macros.h"
-#include "wasp/base/std_hash_macros.h"
 
 namespace wasp {
 
@@ -34,6 +33,3 @@ WASP_BASE_WASM_STRUCTS(WASP_OPERATOR_EQ_NE_VARGS)
 WASP_BASE_WASM_CONTAINERS(WASP_OPERATOR_EQ_NE_CONTAINER)
 
 }  // namespace wasp
-
-WASP_BASE_WASM_STRUCTS(WASP_STD_HASH_VARGS)
-WASP_BASE_WASM_CONTAINERS(WASP_STD_HASH_CONTAINER)
diff --git a/src/binary/linking_section/types.cc b/src/binary/linking_section/types.cc
index 13336034..c460d4d3 100644
--- a/src/binary/linking_section/types.cc
+++ b/src/binary/linking_section/types.cc
@@ -21,7 +21,6 @@
 #include "wasp/base/hash.h"
 #include "wasp/base/macros.h"
 #include "wasp/base/operator_eq_ne_macros.h"
-#include "wasp/base/std_hash_macros.h"
 
 namespace wasp::binary {
 
@@ -101,6 +100,3 @@ WASP_BINARY_LINKING_STRUCTS(WASP_OPERATOR_EQ_NE_VARGS)
 WASP_BINARY_LINKING_CONTAINERS(WASP_OPERATOR_EQ_NE_CONTAINER)
 
 }  // namespace wasp::binary
-
-WASP_BINARY_LINKING_STRUCTS(WASP_STD_HASH_VARGS)
-WASP_BINARY_LINKING_CONTAINERS(WASP_STD_HASH_CONTAINER)
diff --git a/src/binary/name_section/types.cc b/src/binary/name_section/types.cc
index c3658ad4..fc27ca81 100644
--- a/src/binary/name_section/types.cc
+++ b/src/binary/name_section/types.cc
@@ -18,7 +18,6 @@
 
 #include "wasp/base/hash.h"
 #include "wasp/base/operator_eq_ne_macros.h"
-#include "wasp/base/std_hash_macros.h"
 
 namespace wasp::binary {
 
@@ -26,6 +25,3 @@ WASP_BINARY_NAME_STRUCTS(WASP_OPERATOR_EQ_NE_VARGS)
 WASP_BINARY_NAME_CONTAINERS(WASP_OPERATOR_EQ_NE_CONTAINER)
 
 }  // namespace wasp::binary
-
-WASP_BINARY_NAME_STRUCTS(WASP_STD_HASH_VARGS)
-WASP_BINARY_NAME_CONTAINERS(WASP_STD_HASH_CONTAINER)
diff --git a/src/binary/read.cc b/src/binary/read.cc
index ec96c754..9ec3dcec 100644
--- a/src/binary/read.cc
+++ b/src/binary/read.cc
@@ -56,7 +56,7 @@ OptAt<BlockType> Read(SpanU8* data, Context& context, Tag<BlockType>) {
                              context.features);
     return decoded;
   } else if (encoding::BlockType::IsBare(val)) {
-    remove_prefix(data, 1);
+    data->remove_prefix(1);
     WASP_TRY_DECODE_FEATURES(decoded, val, BlockType, "block type",
                              context.features);
     return decoded;
@@ -104,7 +104,7 @@ OptAt<SpanU8> ReadBytes(SpanU8* data, span_extent_t N, Context& context) {
   }
 
   SpanU8 result{data->begin(), N};
-  remove_prefix(data, N);
+  data->remove_prefix(N);
   return At{result, result};
 }
 
@@ -360,7 +360,7 @@ OptAt<ReferenceType> Read(SpanU8* data, Context& context, Tag<ReferenceType>) {
     WASP_TRY_READ(ref_type, Read<RefType>(data, context));
     return At{ref_type.loc(), ReferenceType{ref_type}};
   } else {
-    remove_prefix(data, 1);
+    data->remove_prefix(1);
     WASP_TRY_DECODE_FEATURES(decoded, val, ReferenceKind, "reference type",
                              context.features);
     return At{decoded.loc(), ReferenceType{decoded}};
@@ -497,7 +497,7 @@ OptAt<HeapType> Read(SpanU8* data, Context& context, Tag<HeapType>) {
   ErrorsContextGuard error_guard{context.errors, *data, "heap type"};
   WASP_TRY_READ(val, PeekU8(data, context));
   if (encoding::HeapKind::Is(val)) {
-    remove_prefix(data, 1);
+    data->remove_prefix(1);
     WASP_TRY_DECODE_FEATURES(decoded, val, HeapKind, "heap kind",
                              context.features);
     return At{decoded.loc(), HeapType{decoded}};
@@ -1470,7 +1470,7 @@ auto Read(SpanU8* data, Context& context, Tag<StorageType>)
   WASP_TRY_READ(val, PeekU8(data, context));
 
   if (encoding::PackedType::Is(val)) {
-    remove_prefix(data, 1);
+    data->remove_prefix(1);
     WASP_TRY_DECODE_FEATURES(decoded, val, PackedType, "packed type",
                              context.features);
     return At{decoded.loc(), StorageType{decoded}};
@@ -1505,7 +1505,7 @@ OptAt<string_view> ReadString(SpanU8* data,
   LocationGuard guard{data};
   WASP_TRY_READ(len, ReadLength(data, context));
   string_view result{reinterpret_cast<const char*>(data->data()), len};
-  remove_prefix(data, len);
+  data->remove_prefix(len);
   return At{guard.range(data), result};
 }
 
@@ -1552,7 +1552,7 @@ auto PeekU8(SpanU8* data, Context& context) -> OptAt<u8> {
 OptAt<u8> Read(SpanU8* data, Context& context, Tag<u8>) {
   auto result_opt = PeekU8(data, context);
   if (result_opt) {
-    remove_prefix(data, 1);
+    data->remove_prefix(1);
   }
   return result_opt;
 }
@@ -1572,7 +1572,7 @@ OptAt<ValueType> Read(SpanU8* data, Context& context, Tag<ValueType>) {
   WASP_TRY_READ(val, PeekU8(data, context));
 
   if (encoding::NumericType::Is(val)) {
-    remove_prefix(data, 1);
+    data->remove_prefix(1);
     WASP_TRY_DECODE_FEATURES(decoded, val, NumericType, "value type",
                              context.features);
     return At{decoded.loc(), ValueType{decoded}};
diff --git a/src/binary/types.cc b/src/binary/types.cc
index cfe82282..9b1120ae 100644
--- a/src/binary/types.cc
+++ b/src/binary/types.cc
@@ -19,7 +19,6 @@
 #include "wasp/base/hash.h"
 #include "wasp/base/macros.h"
 #include "wasp/base/operator_eq_ne_macros.h"
-#include "wasp/base/std_hash_macros.h"
 
 namespace wasp::binary {
 
@@ -918,6 +917,3 @@ bool operator==(const Module& lhs, const Module& rhs) {
 bool operator!=(const Module& lhs, const Module& rhs) { return !(lhs == rhs); }
 
 }  // namespace wasp::binary
-
-WASP_BINARY_STRUCTS_CUSTOM_FORMAT(WASP_STD_HASH_VARGS)
-WASP_BINARY_CONTAINERS(WASP_STD_HASH_CONTAINER)
diff --git a/src/text/lex.cc b/src/text/lex.cc
index 948e333e..f33ddce0 100644
--- a/src/text/lex.cc
+++ b/src/text/lex.cc
@@ -28,7 +28,7 @@ struct MatchGuard {
   SpanU8* Reset() { *data_ = orig; return data_; }
   void ResetUnless(bool b) { if (!b) { Reset(); } }
 
-  Location loc() const { return Location(orig.begin(), data_->begin()); }
+  Location loc() const { return MakeSpan(orig.begin(), data_->begin()); }
 
   SpanU8* data_;
   SpanU8 orig;
@@ -79,7 +79,7 @@ auto PeekChar(SpanU8* data, span_extent_t offset = 0) -> int {
 
 void SkipChar(SpanU8* data) {
   assert(!data->empty());
-  remove_prefix(data, 1);
+  data->remove_prefix(1);
 }
 
 int ReadReservedChars(SpanU8* data) {
diff --git a/src/text/types.cc b/src/text/types.cc
index b3164e55..8fc6d781 100644
--- a/src/text/types.cc
+++ b/src/text/types.cc
@@ -21,7 +21,6 @@
 
 #include "wasp/base/hash.h"
 #include "wasp/base/operator_eq_ne_macros.h"
-#include "wasp/base/std_hash_macros.h"
 
 namespace wasp::text {
 
@@ -1307,7 +1306,3 @@ bool operator!=(const BoundValueTypeList& lhs, const ValueTypeList& rhs) {
 }
 
 }  // namespace wasp::text
-
-WASP_TEXT_STRUCTS(WASP_STD_HASH_VARGS)
-WASP_TEXT_STRUCTS_CUSTOM_FORMAT(WASP_STD_HASH_VARGS)
-WASP_TEXT_CONTAINERS(WASP_STD_HASH_CONTAINER)
diff --git a/src/tools/CMakeLists.txt b/src/tools/CMakeLists.txt
index 4f23dcb0..6dc58ce8 100644
--- a/src/tools/CMakeLists.txt
+++ b/src/tools/CMakeLists.txt
@@ -66,7 +66,8 @@ target_link_libraries(wasp_tool
   libwasp_text
   libwasp_binary
   libwasp_base
-  libfmt
+  absl::raw_hash_set
+  absl::str_format
   ${filesystem_lib}
 )
 
diff --git a/src/tools/argparser.cc b/src/tools/argparser.cc
index 4e659bcb..a0383576 100644
--- a/src/tools/argparser.cc
+++ b/src/tools/argparser.cc
@@ -19,12 +19,12 @@
 #include <algorithm>
 #include <iostream>
 
-#include "fmt/format.h"
-#include "fmt/ostream.h"
+#include "absl/strings/str_format.h"
 
 namespace wasp::tools {
 
-using namespace fmt;
+using absl::StrFormat;
+using absl::Format;
 
 ArgParser::Option::Option(LongName long_name, Help help, FlagCallback cb)
     : Option{kInvalidShortName, long_name, help, cb} {}
@@ -83,7 +83,7 @@ ArgParser& ArgParser::AddFeatureFlags(Features& features) {
   return *this;
 }
 
-void ArgParser::Parse(span<string_view> args) {
+void ArgParser::Parse(span<const string_view> args) {
   ArgsGuard guard{*this, args};
 
   for (index_ = 0; index_ < args.size(); ++index_) {
@@ -94,7 +94,7 @@ void ArgParser::Parse(span<string_view> args) {
         if (index_ + 1 < args.size()) {
           get<ParamCallback>(option.callback)(args[++index_]);
         } else {
-          print(std::cerr, "Argument `{}` requires parameter\n.", arg);
+          Format(&std::cerr, "Argument `%s` requires parameter\n.", arg);
         }
         return true;
       } else {
@@ -107,16 +107,16 @@ void ArgParser::Parse(span<string_view> args) {
       if (auto option = FindLongOption(arg)) {
         call(*option);
       } else {
-        print(std::cerr, "Unknown long argument `{}`.\n", arg);
+        Format(&std::cerr, "Unknown long argument `%s`.\n", arg);
       }
     } else if (arg[0] == '-') {
       optional<char> prev_arg_with_param;
       for (auto c : arg.substr(1)) {
         if (prev_arg_with_param) {
-          print(std::cerr,
-                "Argument `-{}` ignored since it follows `-{}` which has a "
-                "parameter.\n",
-                c, *prev_arg_with_param);
+          Format(&std::cerr,
+                 "Argument `-%c` ignored since it follows `-%c` which has a "
+                 "parameter.\n",
+                 c, *prev_arg_with_param);
           continue;
         }
 
@@ -127,7 +127,7 @@ void ArgParser::Parse(span<string_view> args) {
             prev_arg_with_param = c;
           }
         } else {
-          print(std::cerr, "Unknown short argument `-{}`.\n", c);
+          Format(&std::cerr, "Unknown short argument `-%c`.\n", c);
         }
       }
     } else {
@@ -135,24 +135,24 @@ void ArgParser::Parse(span<string_view> args) {
         --index_;  // Back up so call reads arg as the parameter.
         call(*option);
       } else {
-        print(std::cerr, "Unexpected bare argument `{}`.\n", arg);
+        Format(&std::cerr, "Unexpected bare argument `%s`.\n", arg);
       }
     }
   }
 }
 
-span<string_view> ArgParser::RestOfArgs() {
+span<const string_view> ArgParser::RestOfArgs() {
   return args_.subspan(index_ + 1);
 }
 
 std::string ArgParser::GetHelpString() const {
   std::string result;
-  result += format("usage: {}", program_);
+  result += StrFormat("usage: %s", program_);
   if (!options_.empty()) {
     result += " [options]";
   }
   if (auto bare = FindBare()) {
-    result += format(" {}", bare->metavar);
+    result += StrFormat(" %s", bare->metavar);
   }
 
   if (!options_.empty()) {
@@ -173,26 +173,26 @@ std::string ArgParser::GetHelpString() const {
       }
 
       if (option.short_name != kInvalidShortName) {
-        result += format(" -{}, ", option.short_name);
+        result += StrFormat(" -%c, ", option.short_name);
       } else {
         result += "     ";
       }
-      result += format("{:<{}}  {}\n",
-                       format("{} {}", option.long_name, option.metavar), width,
-                       option.help);
+      result += StrFormat("%-*s  %s\n", width,
+                          StrFormat("%s %s", option.long_name, option.metavar),
+                          option.help);
     }
 
     result += "\npositional:\n";
     if (auto option = FindBare()) {
       result +=
-          format(" {:<{}}      {}\n", option->metavar, width, option->help);
+          StrFormat(" %-*s      %s\n", width, option->metavar, option->help);
     }
   }
   return result;
 }
 
 void ArgParser::PrintHelpAndExit(int errcode) {
-  print(std::cerr, GetHelpString());
+  Format(&std::cerr, "%s", GetHelpString());
   exit(errcode);
 }
 
@@ -217,7 +217,7 @@ auto ArgParser::FindBare() const -> optional<Option> {
   return iter != options_.end() ? optional<Option>{*iter} : nullopt;
 }
 
-ArgParser::ArgsGuard::ArgsGuard(ArgParser& parser, span<string_view> args)
+ArgParser::ArgsGuard::ArgsGuard(ArgParser& parser, span<const string_view> args)
     : parser{parser} {
   parser.args_ = args;
   parser.index_ = 0;
diff --git a/src/tools/argparser.h b/src/tools/argparser.h
index 191668ae..1913a77b 100644
--- a/src/tools/argparser.h
+++ b/src/tools/argparser.h
@@ -70,8 +70,8 @@ class ArgParser {
 
   ArgParser& AddFeatureFlags(Features&);
 
-  void Parse(span<string_view>);
-  span<string_view> RestOfArgs();
+  void Parse(span<const string_view>);
+  span<const string_view> RestOfArgs();
 
   std::string GetHelpString() const;
   void PrintHelpAndExit(int errcode);
@@ -87,13 +87,13 @@ class ArgParser {
   std::vector<Option> options_;
 
   struct ArgsGuard {
-    explicit ArgsGuard(ArgParser& parser, span<string_view> args);
+    explicit ArgsGuard(ArgParser& parser, span<const string_view> args);
     ~ArgsGuard();
 
     ArgParser& parser;
   };
 
-  span<string_view> args_;
+  span<const string_view> args_;
   span_extent_t index_ = 0;
 };
 
diff --git a/src/tools/binary_errors.cc b/src/tools/binary_errors.cc
index e0fd0560..ee17950b 100644
--- a/src/tools/binary_errors.cc
+++ b/src/tools/binary_errors.cc
@@ -19,7 +19,7 @@
 #include <iostream>
 #include <utility>
 
-#include "fmt/format.h"
+#include "absl/strings/str_format.h"
 
 namespace wasp::tools {
 
@@ -49,7 +49,7 @@ auto BinaryErrors::ErrorToString(const Error& error) const -> std::string {
   size_t end = data.size() - std::max(after, data.end() - loc.end()) + after;
   end = std::min(end, start + max_size);
 
-  Location context = {data.begin() + start, data.begin() + end};
+  Location context = MakeSpan(data.begin() + start, data.begin() + end);
 
   std::string line1 = "    ";
   std::string line2 = "    ";
@@ -57,7 +57,7 @@ auto BinaryErrors::ErrorToString(const Error& error) const -> std::string {
   bool space = false;
   for (auto iter = context.begin(); iter < context.end(); ++iter) {
     u8 x = *iter;
-    line1 += fmt::format("{:02x}", x);
+    line1 += absl::StrFormat("%02x", x);
     if (iter >= loc.begin() && iter < loc.end()) {
       line2 += "^^";
     } else {
@@ -70,8 +70,9 @@ auto BinaryErrors::ErrorToString(const Error& error) const -> std::string {
     space = !space;
   }
 
-  return fmt::format("{}:{:08x}: {}\n{}\n{}\n", filename,
-                     loc.begin() - data.begin(), error.message, line1, line2);
+  return absl::StrFormat("%s:%08x: %s\n%s\n%s\n", filename,
+                         loc.begin() - data.begin(), error.message, line1,
+                         line2);
 }
 
 }  // namespace wasp::tools
diff --git a/src/tools/callgraph.cc b/src/tools/callgraph.cc
index b5b60c6c..ed3bf524 100644
--- a/src/tools/callgraph.cc
+++ b/src/tools/callgraph.cc
@@ -23,8 +23,7 @@
 #include <string>
 #include <vector>
 
-#include "fmt/format.h"
-#include "fmt/ostream.h"
+#include "absl/strings/str_format.h"
 
 #include "src/tools/argparser.h"
 #include "src/tools/binary_errors.h"
@@ -43,7 +42,7 @@
 
 namespace wasp::tools::callgraph {
 
-using fmt::print;
+using absl::Format;
 
 using namespace ::wasp::binary;
 
@@ -81,7 +80,7 @@ struct Tool {
   std::set<std::pair<Index, Index>> call_graph;
 };
 
-int Main(span<string_view> args) {
+int Main(span<const string_view> args) {
   string_view filename;
   Options options;
   options.features.EnableAll();
@@ -106,19 +105,19 @@ int Main(span<string_view> args) {
         if (filename.empty()) {
           filename = arg;
         } else {
-          print(std::cerr, "Filename already given\n");
+          Format(&std::cerr, "Filename already given\n");
         }
       });
   parser.Parse(args);
 
   if (filename.empty()) {
-    print(std::cerr, "No filenames given.\n");
+    Format(&std::cerr, "No filenames given.\n");
     parser.PrintHelpAndExit(1);
   }
 
   auto optbuf = ReadFile(filename);
   if (!optbuf) {
-    print(std::cerr, "Error reading file {}.\n", filename);
+    Format(&std::cerr, "Error reading file %s.\n", filename);
     return 1;
   }
 
@@ -138,7 +137,7 @@ int Tool::Run() {
   DoPrepass();
   GetFunctionIndex();
   if (options.mode != Mode::All && !options.function_index) {
-    print(std::cerr, "Unknown function {}.\n", *options.function);
+    Format(&std::cerr, "Unknown function %s.\n", *options.function);
     return 1;
   }
   CalculateCallGraph();
@@ -247,8 +246,8 @@ void Tool::WriteDotFile() {
     }
   }
 
-  print(*stream, "strict digraph {{\n");
-  print(*stream, "  rankdir = LR;\n");
+  Format(stream, "strict digraph {\n");
+  Format(stream, "  rankdir = LR;\n");
 
   // Write nodes.
   std::set<Index> functions;
@@ -258,24 +257,24 @@ void Tool::WriteDotFile() {
   }
 
   for (auto function : functions) {
-    print(*stream, "  {}", function);
+    Format(stream, "  %d", function);
     auto name = GetFunctionName(function);
     if (name) {
-      print(*stream, " [label = \"{}\"]", *name);
+      Format(stream, " [label = \"%s\"]", *name);
     } else {
-      print(*stream, " [label = \"f{}\"]", function);
+      Format(stream, " [label = \"f%d\"]", function);
     }
-    print(*stream, ";\n");
+    Format(stream, ";\n");
   }
 
   // Write edges.
   for (auto pair : call_graph) {
     Index caller = pair.first;
     Index callee = pair.second;
-    print(*stream, "  {} -> {};\n", caller, callee);
+    Format(stream, "  %d -> %d;\n", caller, callee);
   }
 
-  print(*stream, "}}\n");
+  Format(stream, "}\n");
   stream->flush();
 }
 
diff --git a/src/tools/callgraph.h b/src/tools/callgraph.h
index 79054f41..0ef64e39 100644
--- a/src/tools/callgraph.h
+++ b/src/tools/callgraph.h
@@ -22,7 +22,7 @@
 
 namespace wasp::tools::callgraph {
 
-int Main(span<string_view> args);
+int Main(span<const string_view> args);
 
 }  // namespace wasp::tools::callgraph
 
diff --git a/src/tools/cfg.cc b/src/tools/cfg.cc
index d6cbe04d..7639e42d 100644
--- a/src/tools/cfg.cc
+++ b/src/tools/cfg.cc
@@ -22,11 +22,11 @@
 #include <string>
 #include <vector>
 
-#include "fmt/format.h"
-#include "fmt/ostream.h"
+#include "absl/strings/str_format.h"
 
 #include "src/tools/argparser.h"
 #include "src/tools/binary_errors.h"
+#include "wasp/base/concat.h"
 #include "wasp/base/enumerate.h"
 #include "wasp/base/features.h"
 #include "wasp/base/file.h"
@@ -43,8 +43,8 @@
 
 namespace wasp::tools::cfg {
 
-using fmt::format;
-using fmt::print;
+using absl::Format;
+using absl::StrFormat;
 
 using namespace ::wasp::binary;
 
@@ -109,7 +109,7 @@ struct Tool {
   BBID current_bbid = InvalidBBID;
 };
 
-int Main(span<string_view> args) {
+int Main(span<const string_view> args) {
   string_view filename;
   Options options;
   options.features.EnableAll();
@@ -126,24 +126,24 @@ int Main(span<string_view> args) {
         if (filename.empty()) {
           filename = arg;
         } else {
-          print(std::cerr, "Filename already given\n");
+          Format(&std::cerr, "Filename already given\n");
         }
       });
   parser.Parse(args);
 
   if (filename.empty()) {
-    print(std::cerr, "No filename given.\n");
+    Format(&std::cerr, "No filename given.\n");
     parser.PrintHelpAndExit(1);
   }
 
   if (options.function.empty()) {
-    print(std::cerr, "No function given.\n");
+    Format(&std::cerr, "No function given.\n");
     parser.PrintHelpAndExit(1);
   }
 
   auto optbuf = ReadFile(filename);
   if (!optbuf) {
-    print(std::cerr, "Error reading file {}.\n", filename);
+    Format(&std::cerr, "Error reading file %s.\n", filename);
     return 1;
   }
 
@@ -163,12 +163,12 @@ int Tool::Run() {
   DoPrepass();
   auto index_opt = GetFunctionIndex();
   if (!index_opt) {
-    print(std::cerr, "Unknown function {}\n", options.function);
+    Format(&std::cerr, "Unknown function %s\n", options.function);
     return 1;
   }
   auto code_opt = GetCode(*index_opt);
   if (!code_opt) {
-    print(std::cerr, "Invalid function index {}\n", *index_opt);
+    Format(&std::cerr, "Invalid function index %d\n", *index_opt);
     return 1;
   }
   CalculateCFG(*code_opt);
@@ -290,7 +290,7 @@ void Tool::CalculateCFG(Code code) {
         const auto& immediate = instr->br_table_immediate();
         u32 value = 0;
         for (const auto& target : immediate->targets) {
-          Br(target, format("{}", value++));
+          Br(target, StrFormat("%d", value++));
         }
         Br(immediate->default_target, "default");
         MarkUnreachable(ptr);
@@ -374,78 +374,78 @@ void Tool::WriteDotFile() {
     }
   }
 
-  print(*stream, "strict digraph {{\n");
+  Format(stream, "strict digraph {\n");
 
   // Write nodes.
   for (const auto& bb: enumerate(cfg)) {
     if (!bb.value.empty()) {
       auto colspan = std::max<int>(
           1, std::min<int>(static_cast<int>(bb.value.successors.size()), kMaxSuccessors));
-      print(*stream,
-            "  {} [shape=none;margin=0;label=<"
-            "<TABLE BORDER=\"1\" CELLBORDER=\"1\" CELLSPACING=\"0\"><TR>"
-            "<TD BORDER=\"0\" ALIGN=\"LEFT\" COLSPAN=\"{}\">",
-            bb.index, colspan);
+      Format(stream,
+             "  %d [shape=none;margin=0;label=<"
+             "<TABLE BORDER=\"1\" CELLBORDER=\"1\" CELLSPACING=\"0\"><TR>"
+             "<TD BORDER=\"0\" ALIGN=\"LEFT\" COLSPAN=\"%d\">",
+             bb.index, colspan);
       auto instrs = ReadExpression(bb.value.code, module.context);
       for (const auto& instr: instrs) {
         if (IsExtraneousInstruction(instr)) {
           continue;
         } else if (instr->opcode == Opcode::BrTable) {
-          print(*stream, "{}...", instr->opcode);
+          Format(stream, "%s...", concat(instr->opcode));
         } else {
-          print(*stream, "{}", *instr);
+          Format(stream, "%s", concat(*instr));
         }
-        print(*stream, "<BR ALIGN=\"LEFT\"/>");
+        Format(stream, "<BR ALIGN=\"LEFT\"/>");
       }
-      print(*stream, "</TD></TR>");
+      Format(stream, "</TD></TR>");
       // Add ports.
       if (bb.value.successors.size() > 1) {
-        print(*stream, "<TR>");
+        Format(stream, "<TR>");
         string_view sides = "T";
         for (const auto& succ: enumerate(bb.value.successors)) {
           if (succ.index < kMaxSuccessors) {
             assert(!succ.value.name.empty());
-            print(*stream, "<TD PORT=\"{}\" SIDES=\"{}\">{}</TD>",
+            Format(stream, "<TD PORT=\"%s\" SIDES=\"%s\">%s</TD>",
                   succ.value.name, sides, succ.value.name);
           } else {
-            print(*stream, "<TD PORT=\"trunc\" SIDES=\"TL\">...</TD>");
+            Format(stream, "<TD PORT=\"trunc\" SIDES=\"TL\">...</TD>");
             break;
           }
           sides = "TL";
         }
-        print(*stream, "</TR>");
+        Format(stream, "</TR>");
       }
-      print(*stream, "</TABLE>>]\n");
+      Format(stream, "</TABLE>>]\n");
     }
   }
 
   // Write edges.
-  print(*stream, "  start -> {}\n", start_bbid);
+  Format(stream, "  start -> %d\n", start_bbid);
   for (const auto& bb: enumerate(cfg)) {
     if (!bb.value.empty()) {
       for (const auto& succ : enumerate(bb.value.successors)) {
         if (succ.value.bbid == InvalidBBID) {
-          print(*stream, "  {} -> end", bb.index);
+          Format(stream, "  %d -> end", bb.index);
         } else {
-          print(*stream, "  {}", bb.index);
+          Format(stream, "  %d", bb.index);
           if (!succ.value.name.empty()) {
             if (succ.index < kMaxSuccessors) {
-              print(*stream, ":{}", succ.value.name);
+              Format(stream, ":%s", succ.value.name);
             } else {
-              print(*stream, ":trunc");
+              Format(stream, ":trunc");
             }
           }
-          print(*stream, " -> {}", succ.value.bbid);
+          Format(stream, " -> %d", succ.value.bbid);
           if (succ.index >= kMaxSuccessors && !succ.value.name.empty()) {
-            print(*stream, " [headlabel=\"{}\"]", succ.value.name);
+            Format(stream, " [headlabel=\"%s\"]", succ.value.name);
           }
-          print(*stream, "\n");
+          Format(stream, "\n");
         }
       }
     }
   }
 
-  print(*stream, "}}\n");
+  Format(stream, "}\n");
   stream->flush();
 }
 
@@ -476,14 +476,14 @@ void Tool::StartBasicBlock(BBID bbid, const u8* start) {
   }
   current_bbid = bbid;
   if (current_bbid != InvalidBBID) {
-    GetBasicBlock(current_bbid).code = SpanU8{start, start};
+    GetBasicBlock(current_bbid).code = MakeSpan(start, start);
   }
 }
 
 void Tool::EndBasicBlock(const u8* end) {
   auto& bb = GetBasicBlock(current_bbid);
   const u8* start = bb.code.data();
-  bb.code = SpanU8{start, end};
+  bb.code = MakeSpan(start, end);
 
   auto instrs = ReadExpression(bb.code, module.context);
   if (std::all_of(instrs.begin(), instrs.end(), IsExtraneousInstruction)) {
@@ -507,7 +507,7 @@ void Tool::Br(Index index, const std::string& name) {
   if (index < labels.size()) {
     AddSuccessor(labels[labels.size() - index - 1].br, name);
   } else {
-    print(std::cerr, "Invalid branch depth: {}\n", index);
+    Format(&std::cerr, "Invalid branch depth: %d\n", index);
   }
 }
 
diff --git a/src/tools/cfg.h b/src/tools/cfg.h
index 00408c0e..e3491645 100644
--- a/src/tools/cfg.h
+++ b/src/tools/cfg.h
@@ -22,7 +22,7 @@
 
 namespace wasp::tools::cfg {
 
-int Main(span<string_view> args);
+int Main(span<const string_view> args);
 
 }  // namespace wasp::tools::cfg
 
diff --git a/src/tools/dfg.cc b/src/tools/dfg.cc
index f0babc06..eb81e6b9 100644
--- a/src/tools/dfg.cc
+++ b/src/tools/dfg.cc
@@ -21,11 +21,11 @@
 #include <set>
 #include <string>
 
-#include "fmt/format.h"
-#include "fmt/ostream.h"
+#include "absl/strings/str_format.h"
 
 #include "src/tools/argparser.h"
 #include "src/tools/binary_errors.h"
+#include "wasp/base/concat.h"
 #include "wasp/base/enumerate.h"
 #include "wasp/base/errors_nop.h"
 #include "wasp/base/features.h"
@@ -45,8 +45,8 @@ namespace wasp {
 namespace tools {
 namespace dfg {
 
-using fmt::format;
-using fmt::print;
+using absl::Format;
+using absl::StrFormat;
 
 using namespace ::wasp::binary;
 
@@ -157,7 +157,7 @@ struct Tool {
   ValueID undef = InvalidValueID;
 };
 
-int Main(span<string_view> args) {
+int Main(span<const string_view> args) {
   string_view filename;
   Options options;
   options.features.EnableAll();
@@ -174,24 +174,24 @@ int Main(span<string_view> args) {
         if (filename.empty()) {
           filename = arg;
         } else {
-          print(std::cerr, "Filename already given\n");
+          Format(&std::cerr, "Filename already given\n");
         }
       });
   parser.Parse(args);
 
   if (filename.empty()) {
-    print(std::cerr, "No filename given.\n");
+    Format(&std::cerr, "No filename given.\n");
     parser.PrintHelpAndExit(1);
   }
 
   if (options.function.empty()) {
-    print(std::cerr, "No function given.\n");
+    Format(&std::cerr, "No function given.\n");
     parser.PrintHelpAndExit(1);
   }
 
   auto optbuf = ReadFile(filename);
   if (!optbuf) {
-    print(std::cerr, "Error reading file {}.\n", filename);
+    Format(&std::cerr, "Error reading file %s.\n", filename);
     return 1;
   }
 
@@ -211,13 +211,13 @@ int Tool::Run() {
   DoPrepass();
   auto index_opt = GetFunctionIndex();
   if (!index_opt) {
-    print(std::cerr, "Unknown function {}\n", options.function);
+    Format(&std::cerr, "Unknown function %s\n", options.function);
     return 1;
   }
   auto ft_opt = GetFunctionType(*index_opt);
   auto code_opt = GetCode(*index_opt);
   if (!ft_opt || !code_opt) {
-    print(std::cerr, "Invalid function index {}\n", *index_opt);
+    Format(&std::cerr, "Invalid function index %d\n", *index_opt);
     return 1;
   }
   CalculateDFG(*ft_opt, *code_opt);
@@ -457,7 +457,8 @@ void Tool::DoInstruction(const Instruction& instr) {
         BasicInstruction(instr, func_type_opt->param_types.size(),
                          func_type_opt->result_types.size());
       } else {
-        print(std::cerr, "*** Error: `{}` with unknown function\n", instr);
+        Format(&std::cerr, "*** Error: `%s` with unknown function\n",
+               concat(instr));
       }
       if (instr.opcode == Opcode::ReturnCall) {
         Return();
@@ -475,7 +476,8 @@ void Tool::DoInstruction(const Instruction& instr) {
         BasicInstruction(instr, func_type->param_types.size() + 1,
                          func_type->result_types.size());
       } else {
-        print(std::cerr, "*** Error: `{}` with unknown type\n", instr);
+        Format(&std::cerr, "*** Error: `%s` with unknown type\n",
+               concat(instr));
       }
       if (instr.opcode == Opcode::ReturnCallIndirect) {
         Return();
@@ -1078,7 +1080,7 @@ void Tool::Br(Index index) {
     AddPred(target);
     ForwardValues(label, target);
   } else {
-    print(std::cerr, "*** Error: Invalid br depth {}\n", index);
+    Format(&std::cerr, "*** Error: Invalid br depth %d\n", index);
   }
 }
 
@@ -1127,8 +1129,8 @@ void Tool::CopyValues(size_t count, ValueIDs& out) {
       out[i] = ReadVariable(static_cast<VarID>(value_stack_size - count + i), current_bbid);
     }
   } else {
-    print(std::cerr, "*** Error: CopyValues({}) past bottom of stack {}\n",
-          count, GetStackSize());
+    Format(&std::cerr, "*** Error: CopyValues(%d) past bottom of stack %d\n",
+           count, GetStackSize());
   }
 }
 
@@ -1166,8 +1168,8 @@ void Tool::PopValues(size_t count) {
   if (count <= stack_size) {
     value_stack_size -= count;
   } else {
-    print(std::cerr, "*** Error: PopValues({}) past bottom of stack {}\n",
-          count, GetStackSize());
+    Format(&std::cerr, "*** Error: PopValues(%d) past bottom of stack %d\n",
+           count, GetStackSize());
     value_stack_size -= stack_size;
   }
 }
@@ -1379,26 +1381,26 @@ void Tool::WriteDotFile() {
 
   std::vector<std::pair<ValueID, ValueID>> interblock_edges;
 
-  print(*stream, "strict digraph {{\n");
+  Format(stream, "strict digraph {\n");
 
   // Write clusters.
   for (const auto& pair : blocks) {
     auto bbid = pair.first;
     const auto& block_vids = pair.second;
 
-    print(*stream, "  subgraph cluster_{} {{\n", bbid);
+    Format(stream, "  subgraph cluster_%d {\n", bbid);
 
     // Write nodes.
     for (const auto& vid : block_vids) {
       if (should_display(vid)) {
         const auto& value = GetValue(vid);
-        print(*stream, "    {} [shape=box;label=\"", vid);
+        Format(stream, "    %d [shape=box;label=\"", vid);
         if (value.is_phi()) {
-          print(*stream, "phi");
+          Format(stream, "phi");
         } else {
-          print(*stream, "{}", EscapeString(format("{}", *value.instr)));
+          Format(stream, "%s", EscapeString(concat(*value.instr)));
         }
-        print(*stream, "\"]\n");
+        Format(stream, "\"]\n");
       }
     }
 
@@ -1407,22 +1409,22 @@ void Tool::WriteDotFile() {
       const auto& value = GetValue(vid);
       for (const auto& op : value.operands) {
         if (GetValue(op).block == bbid) {
-          print(*stream, "    {} -> {}\n", op, vid);
+          Format(stream, "    %d -> %d\n", op, vid);
         } else {
           interblock_edges.push_back(std::make_pair(op, vid));
         }
       }
     }
 
-    print(*stream, "  }}\n");
+    Format(stream, "  }\n");
   }
 
   // Write edges that span between blocks.
   for (const auto& pair : interblock_edges) {
-    print(*stream, "  {} -> {}\n", pair.first, pair.second);
+    Format(stream, "  %d -> %d\n", pair.first, pair.second);
   }
 
-  print(*stream, "}}\n");
+  Format(stream, "}\n");
   stream->flush();
 }
 
diff --git a/src/tools/dfg.h b/src/tools/dfg.h
index 09ebfe8b..d1fdf916 100644
--- a/src/tools/dfg.h
+++ b/src/tools/dfg.h
@@ -22,7 +22,7 @@
 
 namespace wasp::tools::dfg {
 
-int Main(span<string_view> args);
+int Main(span<const string_view> args);
 
 }  // namespace wasp::tools::dfg
 
diff --git a/src/tools/dump.cc b/src/tools/dump.cc
index f45d5627..6006492a 100644
--- a/src/tools/dump.cc
+++ b/src/tools/dump.cc
@@ -21,11 +21,11 @@
 #include <string>
 #include <vector>
 
-#include "fmt/format.h"
-#include "fmt/ostream.h"
+#include "absl/strings/str_format.h"
 
 #include "src/tools/argparser.h"
 #include "src/tools/binary_errors.h"
+#include "wasp/base/concat.h"
 #include "wasp/base/enumerate.h"
 #include "wasp/base/features.h"
 #include "wasp/base/file.h"
@@ -48,8 +48,9 @@ namespace wasp {
 namespace tools {
 namespace dump {
 
-using fmt::format;
-using fmt::print;
+using absl::Format;
+using absl::PrintF;
+using absl::StrFormat;
 
 using namespace ::wasp::binary;
 
@@ -150,8 +151,8 @@ struct Tool {
   enum class PrintChars { No, Yes };
 
   bool ShouldPrintDetails(Pass) const;
-  template <typename... Args>
-  void PrintDetails(Pass, const char* format, const Args&...);
+  template <typename Format, typename... Args>
+  void PrintDetails(Pass, Format format, const Args&...);
   void PrintFunctionName(Index func_index);
   void PrintGlobalName(Index global_index);
   void PrintMemory(SpanU8 data,
@@ -201,7 +202,7 @@ struct Tool {
 // static
 constexpr int Tool::max_octets_per_line;
 
-int Main(span<string_view> args) {
+int Main(span<const string_view> args) {
   std::vector<string_view> filenames;
   Options options;
   options.features.EnableAll();
@@ -228,24 +229,24 @@ int Main(span<string_view> args) {
   parser.Parse(args);
 
   if (filenames.empty()) {
-    print(std::cerr, "No filenames given.\n");
+    Format(&std::cerr, "No filenames given.\n");
     parser.PrintHelpAndExit(1);
   }
 
   if (!(options.print_headers || options.print_disassembly ||
         options.print_details || options.print_raw_data)) {
-    print(std::cerr, "At least one of the following switches must be given:\n");
-    print(std::cerr, " -d/--disassemble\n");
-    print(std::cerr, " -h/--headers\n");
-    print(std::cerr, " -x/--details\n");
-    print(std::cerr, " -s/--full-contents\n");
+    Format(&std::cerr, "At least one of the following switches must be given:\n");
+    Format(&std::cerr, " -d/--disassemble\n");
+    Format(&std::cerr, " -h/--headers\n");
+    Format(&std::cerr, " -x/--details\n");
+    Format(&std::cerr, " -s/--full-contents\n");
     parser.PrintHelpAndExit(1);
   }
 
   for (auto filename : filenames) {
     auto optbuf = ReadFile(filename);
     if (!optbuf) {
-      print(std::cerr, "Error reading file {}.\n", filename);
+      Format(&std::cerr, "Error reading file %s.\n", filename);
       continue;
     }
 
@@ -270,15 +271,15 @@ void Tool::Run() {
     return;
   }
 
-  print("\n{}:\tfile format wasm {}\n", filename,
-        FormatWrapper{*module.version});
+  PrintF("\n%s:\tfile format wasm %s\n", filename,
+         concat(FormatWrapper{*module.version}));
   DoPrepass();
   // If we haven't found a function with the given name, try interpreting it as
   // an index.
   if (options.function && !options.func_index) {
     options.func_index = StrToU32(*options.function);
     if (!options.func_index) {
-      print(std::cerr, "unknown function {}\n", *options.function);
+      Format(&std::cerr, "unknown function %s\n", concat(*options.function));
       return;
     }
   }
@@ -301,7 +302,7 @@ void Tool::DoPrepass() {
     section_starts[section.index] = file_offset(section.value->data());
     if (section.value->is_known()) {
       auto known = section.value->known();
-      section_names[section.index] = format("{}", known->id);
+      section_names[section.index] = concat(known->id);
       switch (known->id) {
         case SectionId::Type: {
           auto seq = ReadTypeSection(known, module.context).sequence;
@@ -426,15 +427,15 @@ void Tool::DoPrepass() {
 void Tool::DoPass(Pass pass) {
   switch (pass) {
     case Pass::Headers:
-      print("\nSections:\n\n");
+      PrintF("\nSections:\n\n");
       break;
 
     case Pass::Details:
-      print("\nSection Details:\n\n");
+      PrintF("\nSection Details:\n\n");
       break;
 
     case Pass::Disassemble:
-      print("\nCode Disassembly:\n\n");
+      PrintF("\nCode Disassembly:\n\n");
       break;
 
     case Pass::RawData:
@@ -483,7 +484,7 @@ bool Tool::SectionMatches(Section section) const {
 
   std::string name;
   if (section.is_known()) {
-    name = format("{}", section.known()->id);
+    name = concat(section.known()->id);
   } else if (section.is_custom()) {
     name = section.custom()->name;
   }
@@ -495,11 +496,11 @@ void Tool::DoCustomSection(Pass pass,
                            CustomSection custom) {
   switch (pass) {
     case Pass::Headers:
-      print("\"{}\"\n", custom.name);
+      PrintF("\"%s\"\n", custom.name);
       break;
 
     case Pass::Details:
-      print(":\n - name: \"{}\"\n", custom.name);
+      PrintF(":\n - name: \"%s\"\n", custom.name);
       if (*custom.name == "name") {
         DoNameSection(pass, section_index,
                       ReadNameSection(custom, module.context));
@@ -525,13 +526,13 @@ void Tool::DoSectionHeader(Pass pass,
   auto size = data.size();
   switch (pass) {
     case Pass::Headers: {
-      print("{:>9} start={:#010x} end={:#010x} (size={:#010x}) ", id, offset,
-            offset + size, size);
+      PrintF("%9s start=%#010x end=%#010x (size=%#010x) ", concat(id), offset,
+             offset + size, size);
       break;
     }
 
     case Pass::Details:
-      print("{}", id);
+      PrintF("%s", concat(id));
       break;
 
     case Pass::Disassemble:
@@ -539,9 +540,9 @@ void Tool::DoSectionHeader(Pass pass,
 
     case Pass::RawData: {
       if (section.is_custom()) {
-        print("\nContents of custom section ({}):\n", section.custom()->name);
+        PrintF("\nContents of custom section (%s):\n", section.custom()->name);
       } else {
-        print("\nContents of section {}:\n", id);
+        PrintF("\nContents of section %s:\n", concat(id));
       }
       PrintMemory(data, static_cast<Index>(offset), PrintChars::Yes);
       break;
@@ -556,7 +557,7 @@ visit::Result Tool::Visitor::BeginTypeSection(LazyTypeSection section) {
 }
 
 visit::Result Tool::Visitor::OnType(const At<DefinedType>& defined_type) {
-  print(" - type[{}] {}\n", index++, defined_type);
+  PrintF(" - type[%d] %s\n", index++, concat(defined_type));
   return visit::Result::Ok;
 }
 
@@ -573,37 +574,37 @@ visit::Result Tool::Visitor::BeginImportSection(LazyImportSection section) {
 visit::Result Tool::Visitor::OnImport(const At<Import>& import) {
   switch (import->kind()) {
     case ExternalKind::Function: {
-      print(" - func[{}] sig={}", function_count, import->index());
+      PrintF(" - func[%d] sig=%d", function_count, import->index());
       tool.PrintFunctionName(function_count);
       ++function_count;
       break;
     }
 
     case ExternalKind::Table: {
-      print(" - table[{}] {}", table_count, import->table_type());
+      PrintF(" - table[%d] %s", table_count, concat(import->table_type()));
       ++table_count;
       break;
     }
 
     case ExternalKind::Memory: {
-      print(" - memory[{}] {}", memory_count, import->memory_type());
+      PrintF(" - memory[%d] %s", memory_count, concat(import->memory_type()));
       ++memory_count;
       break;
     }
 
     case ExternalKind::Global: {
-      print(" - global[{}] {}", global_count, import->global_type());
+      PrintF(" - global[%d] %s", global_count, concat(import->global_type()));
       ++global_count;
       break;
     }
 
     case ExternalKind::Event: {
-      print(" - event[{}] {}", event_count, import->event_type());
+      PrintF(" - event[%d] %s", event_count, concat(import->event_type()));
       ++event_count;
       break;
     }
   }
-  print(" <- {}.{}\n", import->module, import->name);
+  PrintF(" <- %s.%s\n", import->module, import->name);
   return visit::Result::Ok;
 }
 
@@ -615,9 +616,9 @@ visit::Result Tool::Visitor::BeginFunctionSection(LazyFunctionSection section) {
 
 visit::Result Tool::Visitor::OnFunction(const At<Function>& func) {
   if (!tool.options.func_index || index == tool.options.func_index) {
-    print(" - func[{}] sig={}", index, func->type_index);
+    PrintF(" - func[%d] sig=%d", index, func->type_index);
     tool.PrintFunctionName(index);
-    print("\n");
+    PrintF("\n");
   }
   ++index;
   return visit::Result::Ok;
@@ -630,7 +631,7 @@ visit::Result Tool::Visitor::BeginTableSection(LazyTableSection section) {
 }
 
 visit::Result Tool::Visitor::OnTable(const At<Table>& table) {
-  print(" - table[{}] {}\n", index++, table->table_type);
+  PrintF(" - table[%d] %s\n", index++, concat(table->table_type));
   return visit::Result::Ok;
 }
 
@@ -641,7 +642,7 @@ visit::Result Tool::Visitor::BeginMemorySection(LazyMemorySection section) {
 }
 
 visit::Result Tool::Visitor::OnMemory(const At<Memory>& memory) {
-  print(" - memory[{}] {}\n", index++, memory->memory_type);
+  PrintF(" - memory[%d] %s\n", index++, concat(memory->memory_type));
   return visit::Result::Ok;
 }
 
@@ -652,7 +653,8 @@ visit::Result Tool::Visitor::BeginGlobalSection(LazyGlobalSection section) {
 }
 
 visit::Result Tool::Visitor::OnGlobal(const At<Global>& global) {
-  print(" - global[{}] {} - {}\n", index++, global->global_type, global->init);
+  PrintF(" - global[%d] %s - %s\n", index++, concat(global->global_type),
+         concat(global->init));
   return visit::Result::Ok;
 }
 
@@ -663,7 +665,7 @@ visit::Result Tool::Visitor::BeginEventSection(LazyEventSection section) {
 }
 
 visit::Result Tool::Visitor::OnEvent(const At<Event>& event) {
-  print(" - event[{}] {}\n", index++, event->event_type);
+  PrintF(" - event[%d] %s\n", index++, concat(event->event_type));
   return visit::Result::Ok;
 }
 
@@ -673,11 +675,11 @@ visit::Result Tool::Visitor::BeginExportSection(LazyExportSection section) {
 }
 
 visit::Result Tool::Visitor::OnExport(const At<Export>& export_) {
-  print(" - {}[{}]", export_->kind, export_->index);
+  PrintF(" - %s[%d]", concat(export_->kind), export_->index);
   if (export_->kind == ExternalKind::Function) {
     tool.PrintFunctionName(export_->index);
   }
-  print(" -> \"{}\"\n", export_->name);
+  PrintF(" -> \"%s\"\n", export_->name);
   return visit::Result::Ok;
 }
 
@@ -685,9 +687,11 @@ visit::Result Tool::Visitor::BeginStartSection(StartSection section) {
   if (section) {
     auto start = *section;
     if (pass == Pass::Headers) {
-      print("start: {}\n", start->func_index);
+      PrintF("start: %d\n", start->func_index);
     } else {
-      tool.PrintDetails(pass, " - start function: {}\n", start->func_index);
+      tool.PrintDetails(pass,
+                        absl::ParsedFormat<'d'>(" - start function: %d\n"),
+                        start->func_index);
     }
   }
   return visit::Result::Ok;
@@ -700,33 +704,33 @@ visit::Result Tool::Visitor::BeginElementSection(LazyElementSection section) {
 }
 
 visit::Result Tool::Visitor::OnElement(const At<ElementSegment>& segment) {
-  print(" - segment[{}] {}", index, segment->type);
+  PrintF(" - segment[%d] %s", index, concat(segment->type));
   if (segment->table_index) {
-    print(" table={}", *segment->table_index);
+    PrintF(" table=%d", *segment->table_index);
   }
 
   if (segment->has_indexes()) {
-    print(" kind={} count={}", segment->indexes().kind,
-          segment->indexes().list.size());
+    PrintF(" kind=%s count=%d", concat(segment->indexes().kind),
+           segment->indexes().list.size());
   } else if (segment->has_expressions()) {
-    print(" elemtype={} count={}", segment->expressions().elemtype,
-          segment->expressions().list.size());
+    PrintF(" elemtype=%s count=%d", concat(segment->expressions().elemtype),
+           segment->expressions().list.size());
   }
 
   Index offset = 0;
   if (segment->offset) {
     offset = tool.GetI32Value(*segment->offset).value_or(0);
-    print(" - init {}", offset);
+    PrintF(" - init %d", offset);
   }
-  print("\n");
+  PrintF("\n");
 
   if (segment->has_indexes()) {
     for (auto item : enumerate(segment->indexes().list)) {
-      print("  - elem[{}] = {}\n", offset + item.index, item.value);
+      PrintF("  - elem[%d] = %d\n", offset + item.index, item.value);
     }
   } else if (segment->has_expressions()) {
     for (auto item : enumerate(segment->expressions().list)) {
-      print("  - elem[{}] = {}\n", offset + item.index, item.value);
+      PrintF("  - elem[%d] = %s\n", offset + item.index, concat(item.value));
     }
   }
 
@@ -738,9 +742,10 @@ visit::Result Tool::Visitor::BeginDataCountSection(DataCountSection section) {
   if (section) {
     auto data_count = *section;
     if (pass == Pass::Headers) {
-      print("count: {}\n", data_count->count);
+      PrintF("count: %d\n", data_count->count);
     } else {
-      tool.PrintDetails(pass, " - data count: {}\n", data_count->count);
+      tool.PrintDetails(pass, absl::ParsedFormat<'d'>(" - data count: %d\n"),
+                        data_count->count);
     }
   }
   return visit::Result::Ok;
@@ -755,7 +760,7 @@ visit::Result Tool::Visitor::BeginCodeSection(LazyCodeSection section) {
 visit::Result Tool::Visitor::BeginCode(const At<Code>& code) {
   if (!tool.options.func_index || index == tool.options.func_index) {
     if (pass == Pass::Details) {
-      print(" - func[{}] size={}\n", index, code->body->data.size());
+      PrintF(" - func[%d] size=%d\n", index, code->body->data.size());
     } else {
       tool.Disassemble(section_index, index, code);
     }
@@ -772,17 +777,17 @@ visit::Result Tool::Visitor::BeginDataSection(LazyDataSection section) {
 }
 
 visit::Result Tool::Visitor::OnData(const At<DataSegment>& segment) {
-  print(" - segment[{}] {}", index, segment->type);
+  PrintF(" - segment[%d] %s", index, concat(segment->type));
   if (segment->memory_index) {
-    print(" memory={}", *segment->memory_index);
+    PrintF(" memory=%d", *segment->memory_index);
   }
-  print(" size={}", segment->init.size());
+  PrintF(" size=%d", segment->init.size());
   Index offset = 0;
   if (segment->offset) {
     offset = tool.GetI32Value(*segment->offset).value_or(0);
-    print(" - init {}", offset);
+    PrintF(" - init %d", offset);
   }
-  print("\n");
+  PrintF("\n");
   tool.PrintMemory(segment->init, offset, PrintChars::Yes, "  - ");
   ++index;
   return visit::Result::Ok;
@@ -800,18 +805,18 @@ void Tool::DoNameSection(Pass pass,
       case NameSubsectionId::ModuleName: {
         auto module_name =
             ReadModuleNameSubsection(subsection->data, module.context);
-        print("  module name: {}\n", module_name.value_or(""));
+        PrintF("  module name: %s\n", module_name.value_or(""));
         break;
       }
 
       case NameSubsectionId::FunctionNames: {
         auto function_names_subsection =
             ReadFunctionNamesSubsection(subsection->data, module.context);
-        print("  function names[{}]:\n",
+        PrintF("  function names[%d]:\n",
               function_names_subsection.count.value_or(0));
         for (auto name_assoc : enumerate(function_names_subsection.sequence)) {
-          print("   - [{}]: func[{}] name=\"{}\"\n", name_assoc.index,
-                name_assoc.value->index, name_assoc.value->name);
+          PrintF("   - [%d]: func[%d] name=\"%s\"\n", name_assoc.index,
+                 name_assoc.value->index, name_assoc.value->name);
         }
         break;
       }
@@ -819,16 +824,16 @@ void Tool::DoNameSection(Pass pass,
       case NameSubsectionId::LocalNames: {
         auto local_names_subsection =
             ReadLocalNamesSubsection(subsection->data, module.context);
-        print("  local names[{}]:\n", local_names_subsection.count.value_or(0));
+        PrintF("  local names[%d]:\n", local_names_subsection.count.value_or(0));
         for (auto indirect_name_assoc :
              enumerate(local_names_subsection.sequence)) {
-          print("   - [{}]: func[{}] count={}\n", indirect_name_assoc.index,
-                indirect_name_assoc.value->index,
-                indirect_name_assoc.value->name_map.size());
+          PrintF("   - [%d]: func[%d] count=%d\n", indirect_name_assoc.index,
+                 indirect_name_assoc.value->index,
+                 indirect_name_assoc.value->name_map.size());
           for (auto name_assoc :
                enumerate(indirect_name_assoc.value->name_map)) {
-            print("     - [{}]: local[{}] name=\"{}\"\n", name_assoc.index,
-                  name_assoc.value->index, name_assoc.value->name);
+            PrintF("     - [%d]: local[%d] name=\"%s\"\n", name_assoc.index,
+                   name_assoc.value->index, name_assoc.value->name);
           }
         }
         break;
@@ -846,12 +851,12 @@ void Tool::DoLinkingSection(Pass pass,
         if (ShouldPrintDetails(pass)) {
           auto segment_infos =
               ReadSegmentInfoSubsection(subsection->data, module.context);
-          print(" - segment info [count={}]\n",
-                segment_infos.count.value_or(0));
+          PrintF(" - segment info [count=%d]\n",
+                 segment_infos.count.value_or(0));
           for (auto segment_info : enumerate(segment_infos.sequence)) {
-            print("  - {}: {} p2align={} flags={:#x}\n", segment_info.index,
-                  segment_info.value->name, segment_info.value->align_log2,
-                  segment_info.value->flags);
+            PrintF("  - %d: %s p2align=%d flags=%#x\n", segment_info.index,
+                   segment_info.value->name, segment_info.value->align_log2,
+                   segment_info.value->flags);
           }
         }
         break;
@@ -861,10 +866,10 @@ void Tool::DoLinkingSection(Pass pass,
         if (ShouldPrintDetails(pass)) {
           auto init_functions =
               ReadInitFunctionsSubsection(subsection->data, module.context);
-          print(" - init functions [count={}]\n",
+          PrintF(" - init functions [count=%d]\n",
                 init_functions.count.value_or(0));
           for (auto init_function : init_functions.sequence) {
-            print("  - {}: priority={}\n", init_function->index,
+            PrintF("  - %d: priority=%d\n", init_function->index,
                   init_function->priority);
           }
         }
@@ -874,14 +879,14 @@ void Tool::DoLinkingSection(Pass pass,
       case LinkingSubsectionId::ComdatInfo: {
         if (ShouldPrintDetails(pass)) {
           auto comdats = ReadComdatSubsection(subsection->data, module.context);
-          print(" - comdat [count={}]\n", comdats.count.value_or(0));
+          PrintF(" - comdat [count=%d]\n", comdats.count.value_or(0));
           for (auto comdat : enumerate(comdats.sequence)) {
-            print("  - {}: \"{}\" flags={:#x} [count={}]\n", comdat.index,
-                  comdat.value->name, comdat.value->flags,
-                  comdat.value->symbols.size());
+            PrintF("  - %d: \"%s\" flags=%#x [count=%d]\n", comdat.index,
+                   comdat.value->name, comdat.value->flags,
+                   comdat.value->symbols.size());
             for (auto symbol : enumerate(comdat.value->symbols)) {
-              print("   - {}: {} index={}\n", symbol.index, symbol.value->kind,
-                    symbol.value->index);
+              PrintF("   - %d: %s index=%d\n", symbol.index,
+                     concat(symbol.value->kind), symbol.value->index);
             }
           }
         }
@@ -892,34 +897,35 @@ void Tool::DoLinkingSection(Pass pass,
         if (ShouldPrintDetails(pass)) {
           auto print_symbol_flags = [&](SymbolInfo::Flags flags) {
             if (flags.undefined == SymbolInfo::Flags::Undefined::Yes) {
-              print(" {}", flags.undefined);
+              PrintF(" %s", concat(flags.undefined));
             }
-            print(" binding={} vis={}", flags.binding, flags.visibility);
+            PrintF(" binding=%s vis=%s", concat(flags.binding),
+                   concat(flags.visibility));
             if (flags.explicit_name == SymbolInfo::Flags::ExplicitName::Yes) {
-              print(" {}", flags.explicit_name);
+              PrintF(" %s", concat(flags.explicit_name));
             }
           };
 
           auto symbol_table =
               ReadSymbolTableSubsection(subsection->data, module.context);
-          print(" - symbol table [count={}]\n",
+          PrintF(" - symbol table [count=%d]\n",
                 symbol_table.count.value_or(0));
           for (auto symbol : enumerate(symbol_table.sequence)) {
             switch (symbol.value->kind()) {
               case SymbolInfoKind::Function: {
                 const auto& base = symbol.value->base();
-                print("  - {}: F <{}> func={}", symbol.index,
-                      base.name.value_or(
-                          GetFunctionName(base.index).value_or("")),
-                      base.index);
+                PrintF("  - %d: F <%s> func=%d", symbol.index,
+                       base.name.value_or(
+                           GetFunctionName(base.index).value_or("")),
+                       base.index);
                 print_symbol_flags(symbol.value->flags);
                 break;
               }
 
               case SymbolInfoKind::Global: {
                 const auto& base = symbol.value->base();
-                print(
-                    "  - {}: G <{}> global={}", symbol.index,
+                PrintF(
+                    "  - %d: G <%s> global=%d", symbol.index,
                     base.name.value_or(GetGlobalName(base.index).value_or("")),
                     base.index);
                 print_symbol_flags(symbol.value->flags);
@@ -929,17 +935,17 @@ void Tool::DoLinkingSection(Pass pass,
               case SymbolInfoKind::Event: {
                 const auto& base = symbol.value->base();
                 // TODO GetEventName.
-                print("  - {}: E <{}> event={}", symbol.index,
-                      base.name.value_or(""_sv), base.index);
+                PrintF("  - %d: E <%s> event=%d", symbol.index,
+                       base.name.value_or(""_sv), base.index);
                 print_symbol_flags(symbol.value->flags);
                 break;
               }
 
               case SymbolInfoKind::Data: {
                 const auto& data = symbol.value->data();
-                print("  - {}: D <{}>", symbol.index, data.name);
+                PrintF("  - %d: D <%s>", symbol.index, data.name);
                 if (data.defined) {
-                  print(" segment={} offset={} size={}", data.defined->index,
+                  PrintF(" segment=%d offset=%d size=%d", data.defined->index,
                         data.defined->offset, data.defined->size);
                 }
                 print_symbol_flags(symbol.value->flags);
@@ -948,14 +954,14 @@ void Tool::DoLinkingSection(Pass pass,
 
               case SymbolInfoKind::Section: {
                 auto section_index = symbol.value->section().section;
-                print("  - {}: S <{}> section={}", symbol.index,
+                PrintF("  - %d: S <%s> section=%d", symbol.index,
                       GetSectionName(section_index).value_or(""),
                       section_index);
                 print_symbol_flags(symbol.value->flags);
                 break;
               }
             }
-            print("\n");
+            PrintF("\n");
           }
         }
         break;
@@ -968,7 +974,9 @@ void Tool::DoRelocationSection(Pass pass,
                                SectionIndex section_index,
                                RelocationSection section) {
   auto reloc_section_index = section.section_index.value_or(-1);
-  PrintDetails(pass, " - relocations for section {} ({}) [{}]\n",
+  PrintDetails(pass,
+               absl::ParsedFormat<'d', 's', 'd'>(
+                   " - relocations for section %d (%s) [%d]\n"),
                reloc_section_index,
                GetSectionName(reloc_section_index).value_or(""),
                section.count.value_or(0));
@@ -979,27 +987,27 @@ void Tool::DoRelocationSection(Pass pass,
       total_offset += start->second;
     }
     if (ShouldPrintDetails(pass)) {
-      print("   - {:18s} offset={:#08x}(file={:#08x}) ", entry->type,
-            entry->offset, total_offset);
+      PrintF("   - %18s offset=%#08x(file=%#08x) ", concat(entry->type),
+             entry->offset, total_offset);
       if (entry->type == RelocationType::TypeIndexLEB) {
-        print("type={}", entry->index);
+        PrintF("type=%d", entry->index);
       } else {
-        print("symbol={} <{}>", entry->index,
+        PrintF("symbol=%d <%s>", entry->index,
               GetSymbolName(entry->index).value_or(""));
       }
       if (entry->addend && *entry->addend != 0) {
-        print("{:+#x}", *entry->addend);
+        PrintF("%+#x", *entry->addend);
       }
-      print("\n");
+      PrintF("\n");
     }
   }
 }
 
 void Tool::DoCount(Pass pass, optional<Index> count) {
   if (pass == Pass::Headers) {
-    print("count: {}\n", count.value_or(0));
+    PrintF("count: %d\n", count.value_or(0));
   } else {
-    PrintDetails(pass, "[{}]:\n", count.value_or(0));
+    PrintDetails(pass, absl::ParsedFormat<'d'>("[%d]:\n"), count.value_or(0));
   }
 }
 
@@ -1154,22 +1162,22 @@ bool Tool::ShouldPrintDetails(Pass pass) const {
   return pass == Pass::Details && should_print_details;
 }
 
-template <typename... Args>
-void Tool::PrintDetails(Pass pass, const char* format, const Args&... args) {
+template <typename Format, typename... Args>
+void Tool::PrintDetails(Pass pass, Format format, const Args&... args) {
   if (ShouldPrintDetails(pass)) {
-    vprint(format, fmt::make_format_args(args...));
+    PrintF(format, args...);
   }
 }
 
 void Tool::PrintFunctionName(Index func_index) {
   if (auto name = GetFunctionName(func_index)) {
-    print(" <{}>", *name);
+    PrintF(" <%s>", *name);
   }
 }
 
 void Tool::PrintGlobalName(Index func_index) {
   if (auto name = GetGlobalName(func_index)) {
-    print(" <{}>", *name);
+    PrintF(" <%s>", *name);
   }
 }
 
@@ -1183,49 +1191,49 @@ void Tool::PrintMemory(SpanU8 start,
   while (!data.empty()) {
     auto line_size = std::min<size_t>(data.size(), octets_per_line);
     const SpanU8 line = data.subspan(0, line_size);
-    print("{}", prefix);
-    print("{:07x}: ", (line.begin() - start.begin()) + offset);
+    PrintF("%s", prefix);
+    PrintF("%07x: ", (line.begin() - start.begin()) + offset);
     for (int i = 0; i < octets_per_line;) {
       for (int j = 0; j < octets_per_group; ++j, ++i) {
         if (i < static_cast<int>(line_size)) {
-          print("{:02x}", line[i]);
+          PrintF("%02x", line[i]);
         } else {
-          print("  ");
+          PrintF("  ");
         }
       }
-      print(" ");
+      PrintF(" ");
     }
 
     if (print_chars == PrintChars::Yes) {
-      print(" ");
+      PrintF(" ");
       for (int c : line) {
-        print("{:c}", isprint(c) ? static_cast<char>(c) : '.');
+        PrintF("%c", isprint(c) ? static_cast<char>(c) : '.');
       }
     }
-    print("\n");
-    remove_prefix(&data, line_size);
+    PrintF("\n");
+    data.remove_prefix(line_size);
   }
 }
 
 void Tool::PrintFunctionHeader(Index func_index, Code code) {
   auto func_type = GetFunctionType(func_index);
   size_t param_count = 0;
-  print("func[{}]", func_index);
+  PrintF("func[%d]", func_index);
   PrintFunctionName(func_index);
-  print(":");
+  PrintF(":");
   if (func_type) {
-    print(" {}\n", *func_type);
+    PrintF(" %s\n", concat(*func_type));
     param_count = func_type->param_types.size();
   } else {
-    print("\n");
+    PrintF("\n");
   }
   size_t local_count = param_count;
   for (auto locals : code.locals) {
-    print(" {:{}s} | locals[{}", "", 7 + max_octets_per_line * 3, local_count);
+    PrintF(" %*s | locals[%d", 7 + max_octets_per_line * 3, "", local_count);
     if (locals->count != 1) {
-      print("..{}", local_count + locals->count - 1);
+      PrintF("..%d", local_count + locals->count - 1);
     }
-    print("] type={}\n", locals->type);
+    PrintF("] type=%s\n", concat(locals->type));
     local_count += locals->count;
   }
 }
@@ -1236,17 +1244,18 @@ void Tool::PrintInstruction(const Instruction& instr,
                             int indent) {
   bool first_line = true;
   while (data.begin() < post_data.begin()) {
-    print(" {:06x}:", file_offset(data));
+    PrintF(" %06x:", file_offset(data));
     int line_octets =
-        std::min<int>(max_octets_per_line, static_cast<int>(post_data.begin() - data.begin()));
+        std::min<int>(max_octets_per_line,
+                      static_cast<int>(post_data.begin() - data.begin()));
     for (int i = 0; i < line_octets; ++i) {
-      print(" {:02x}", data[i]);
+      PrintF(" %02x", data[i]);
     }
-    remove_prefix(&data, line_octets);
-    print("{:{}s} |", "", (max_octets_per_line - line_octets) * 3);
+    data.remove_prefix(line_octets);
+    PrintF("%*s |", (max_octets_per_line - line_octets) * 3, "");
     if (first_line) {
       first_line = false;
-      print(" {:{}s}{}", "", indent, instr);
+      PrintF(" %*s%s", indent, "", concat(instr));
 
       if (instr.opcode == Opcode::Call) {
         PrintFunctionName(instr.index_immediate());
@@ -1258,24 +1267,25 @@ void Tool::PrintInstruction(const Instruction& instr,
         if (block_type->is_index()) {
           auto defined_type_opt = GetDefinedType(block_type->index());
           if (defined_type_opt) {
-            print(" <{}>", defined_type_opt->type);
+            PrintF(" <%s>", concat(defined_type_opt->type));
           }
         }
       }
     }
-    print("\n");
+    PrintF("\n");
   }
 }
 
 void Tool::PrintRelocation(const RelocationEntry& entry, size_t file_offset) {
-  print("           {:06x}: {:18s} {}", file_offset, entry.type, entry.index);
+  PrintF("           %06x: %18s %d", file_offset, concat(entry.type),
+         entry.index);
   if (entry.addend && *entry.addend) {
-    print(" {:+d}", *entry.addend);
+    PrintF(" %+d", *entry.addend);
   }
   if (entry.type != RelocationType::TypeIndexLEB) {
-    print(" <{}>", GetSymbolName(entry.index).value_or(""));
+    PrintF(" <%s>", GetSymbolName(entry.index).value_or(""));
   }
-  print("\n");
+  PrintF("\n");
 }
 
 size_t Tool::file_offset(SpanU8 data) {
diff --git a/src/tools/dump.h b/src/tools/dump.h
index b97a6fa3..ab96b743 100644
--- a/src/tools/dump.h
+++ b/src/tools/dump.h
@@ -22,7 +22,7 @@
 
 namespace wasp::tools::dump {
 
-int Main(span<string_view> args);
+int Main(span<const string_view> args);
 
 }  // namespace wasp::tools::dump
 
diff --git a/src/tools/pattern.cc b/src/tools/pattern.cc
index a273c35a..fe3d06d2 100644
--- a/src/tools/pattern.cc
+++ b/src/tools/pattern.cc
@@ -23,11 +23,11 @@
 #include <string>
 #include <vector>
 
-#include "fmt/format.h"
-#include "fmt/ostream.h"
+#include "absl/strings/str_format.h"
 
 #include "src/tools/argparser.h"
 #include "src/tools/binary_errors.h"
+#include "wasp/base/concat.h"
 #include "wasp/base/enumerate.h"
 #include "wasp/base/features.h"
 #include "wasp/base/file.h"
@@ -43,24 +43,14 @@
 #include "wasp/binary/lazy_module.h"
 #include "wasp/binary/visitor.h"
 
-namespace std {
-
-template <>
-struct hash<std::vector<::wasp::binary::Instruction>> {
-  size_t operator()(const std::vector<::wasp::binary::Instruction>& v) const {
-    return ::wasp::HashContainer(v);
-  }
-};
-
-}  // namespace std
-
 namespace wasp {
 namespace tools {
 namespace pattern {
 
 const size_t kMaxPatternSize = 5;
 
-using fmt::print;
+using absl::PrintF;
+using absl::Format;
 
 using namespace ::wasp::binary;
 
@@ -96,7 +86,7 @@ struct Tool {
   u64 total_instructions = 0;
 };
 
-int Main(span<string_view> args) {
+int Main(span<const string_view> args) {
   string_view filename;
   Options options;
   options.features.EnableAll();
@@ -113,19 +103,19 @@ int Main(span<string_view> args) {
         if (filename.empty()) {
           filename = arg;
         } else {
-          print(std::cerr, "Filename already given\n");
+          Format(&std::cerr, "Filename already given\n");
         }
       });
   parser.Parse(args);
 
   if (filename.empty()) {
-    print(std::cerr, "No filename given.\n");
+    Format(&std::cerr, "No filename given.\n");
     parser.PrintHelpAndExit(1);
   }
 
   auto optbuf = ReadFile(filename);
   if (!optbuf) {
-    print(std::cerr, "Error reading file {}.\n", filename);
+    Format(&std::cerr, "Error reading file %s.\n", filename);
     return 1;
   }
 
@@ -155,11 +145,12 @@ int Tool::Run() {
   for (const auto& pattern : sorted) {
     if (pattern.second > 1) {
       u64 pattern_instructions = u64(pattern.first.size()) * pattern.second;
-      print("{}: [{}] {} {:.2f}%\n", pattern.second, pattern.first.size(),
-            pattern.first, 100.0 * pattern_instructions / total_instructions);
+      PrintF("%d: [%d] %s %.2f%%\n", pattern.second, pattern.first.size(),
+             concat(pattern.first),
+             100.0 * pattern_instructions / total_instructions);
     }
   }
-  print("total instructions: {}\n", total_instructions);
+  PrintF("total instructions: %d\n", total_instructions);
   return 0;
 }
 
diff --git a/src/tools/pattern.h b/src/tools/pattern.h
index a1ec6cf5..8a4db68e 100644
--- a/src/tools/pattern.h
+++ b/src/tools/pattern.h
@@ -22,7 +22,7 @@
 
 namespace wasp::tools::pattern {
 
-int Main(span<string_view> args);
+int Main(span<const string_view> args);
 
 }  // namespace wasp::tools::pattern
 
diff --git a/src/tools/text_errors.cc b/src/tools/text_errors.cc
index 8b31759c..d3b8c067 100644
--- a/src/tools/text_errors.cc
+++ b/src/tools/text_errors.cc
@@ -20,7 +20,7 @@
 #include <algorithm>
 #include <iostream>
 
-#include "fmt/format.h"
+#include "absl/strings/str_format.h"
 
 #include "wasp/base/enumerate.h"
 
@@ -117,14 +117,15 @@ auto TextErrors::ErrorToString(const Error& error) const -> std::string {
   loc_start = clamp(line_start, loc_start, line_end);
   loc_end = clamp(line_start, loc_end, line_end);
 
-  Location context = {data.begin() + line_start, data.begin() + line_end};
+  Location context =
+      MakeSpan(data.begin() + line_start, data.begin() + line_end);
   string_view line1 = ToStringView(context);
   std::string line2 = std::string(loc_start - line_start, ' ') +
                       std::string(loc_end - loc_start, '^') +
                       std::string(line_end - loc_end, ' ');
 
-  return fmt::format("{}:{}:{}: {}\n{}\n{}\n", filename, line, column,
-                     error.message, line1, line2);
+  return absl::StrFormat("%s:%d:%d: %s\n%s\n%s\n", filename, line, column,
+                         error.message, line1, line2);
 }
 
 }  // namespace wasp::tools
diff --git a/src/tools/validate.cc b/src/tools/validate.cc
index f44c608c..00eedd86 100644
--- a/src/tools/validate.cc
+++ b/src/tools/validate.cc
@@ -24,8 +24,7 @@
 #include <string>
 #include <vector>
 
-#include "fmt/format.h"
-#include "fmt/ostream.h"
+#include "absl/strings/str_format.h"
 
 #include "src/tools/argparser.h"
 #include "src/tools/binary_errors.h"
@@ -43,7 +42,8 @@ namespace wasp {
 namespace tools {
 namespace validate {
 
-using fmt::print;
+using absl::Format;
+using absl::PrintF;
 
 using namespace ::wasp::binary;
 
@@ -65,7 +65,7 @@ struct Tool {
   valid::ValidateVisitor visitor;
 };
 
-int Main(span<string_view> args) {
+int Main(span<const string_view> args) {
   std::vector<string_view> filenames;
   Options options;
 
@@ -81,7 +81,7 @@ int Main(span<string_view> args) {
   parser.Parse(args);
 
   if (filenames.empty()) {
-    print("No filenames given.\n");
+    PrintF("No filenames given.\n");
     parser.PrintHelpAndExit(1);
   }
 
@@ -89,7 +89,7 @@ int Main(span<string_view> args) {
   for (auto filename : filenames) {
     auto optbuf = ReadFile(filename);
     if (!optbuf) {
-      print(std::cerr, "Error reading file {}.\n", filename);
+      Format(&std::cerr, "Error reading file %s.\n", filename);
       ok = false;
       continue;
     }
@@ -98,7 +98,7 @@ int Main(span<string_view> args) {
     Tool tool{filename, data, options};
     bool valid = tool.Run();
     if (!valid || options.verbose) {
-      print("[{:^4}] {}\n", valid ? "OK" : "FAIL", filename);
+      PrintF("[%4s] %s\n", valid ? " OK " : "FAIL", filename);
       tool.errors.PrintTo(std::cerr);
     }
     ok &= valid;
diff --git a/src/tools/validate.h b/src/tools/validate.h
index 8c890f6e..6caef8ce 100644
--- a/src/tools/validate.h
+++ b/src/tools/validate.h
@@ -22,7 +22,7 @@
 
 namespace wasp::tools::validate {
 
-int Main(span<string_view> args);
+int Main(span<const string_view> args);
 
 }  // namespace wasp::tools::validate
 
diff --git a/src/tools/wasp.cc b/src/tools/wasp.cc
index 21ee48e6..bcbf40c5 100644
--- a/src/tools/wasp.cc
+++ b/src/tools/wasp.cc
@@ -18,8 +18,7 @@
 #include <iostream>
 #include <map>
 
-#include "fmt/format.h"
-#include "fmt/ostream.h"
+#include "absl/strings/str_format.h"
 
 #include "src/tools/argparser.h"
 #include "src/tools/callgraph.h"
@@ -36,9 +35,9 @@
 
 using namespace ::wasp;
 
-using fmt::print;
+using absl::Format;
 
-using Command = int (*)(span<string_view> args);
+using Command = int (*)(span<const string_view> args);
 
 void PrintHelp(int);
 
@@ -61,7 +60,7 @@ int main(int argc, char** argv) {
       .Add("<command>", "command", [&](string_view arg) {
         auto iter = commands.find(arg);
         if (iter == commands.end()) {
-          print(std::cerr, "Unknown command `{}`\n", arg);
+          Format(&std::cerr, "Unknown command `%s`\n", arg);
           PrintHelp(1);
         } else {
           exit(iter->second(parser.RestOfArgs()));
@@ -72,15 +71,15 @@ int main(int argc, char** argv) {
 }
 
 void PrintHelp(int errcode) {
-  print(std::cerr, "usage: wasp <command> [<options>]\n");
-  print(std::cerr, "\n");
-  print(std::cerr, "commands:\n");
-  print(std::cerr, "  dump        Dump the contents of a WebAssembly file.\n");
-  print(std::cerr, "  callgraph   Generate DOT file for the function call graph.\n");
-  print(std::cerr, "  cfg         Generate DOT file of a function's control flow graph.\n");
-  print(std::cerr, "  dfg         Generate DOT file of a function's data flow graph.\n");
-  print(std::cerr, "  validate    Validate a WebAssembly file.\n");
-  print(std::cerr, "  pattern     Find common instruction sequences.\n");
-  print(std::cerr, "  wat2wasm    Convert a WebAssembly text file to binary.\n");
+  Format(&std::cerr, "usage: wasp <command> [<options>]\n");
+  Format(&std::cerr, "\n");
+  Format(&std::cerr, "commands:\n");
+  Format(&std::cerr, "  dump        Dump the contents of a WebAssembly file.\n");
+  Format(&std::cerr, "  callgraph   Generate DOT file for the function call graph.\n");
+  Format(&std::cerr, "  cfg         Generate DOT file of a function's control flow graph.\n");
+  Format(&std::cerr, "  dfg         Generate DOT file of a function's data flow graph.\n");
+  Format(&std::cerr, "  validate    Validate a WebAssembly file.\n");
+  Format(&std::cerr, "  pattern     Find common instruction sequences.\n");
+  Format(&std::cerr, "  wat2wasm    Convert a WebAssembly text file to binary.\n");
   exit(errcode);
 }
diff --git a/src/tools/wat2wasm.cc b/src/tools/wat2wasm.cc
index 419beb22..30d431a9 100644
--- a/src/tools/wat2wasm.cc
+++ b/src/tools/wat2wasm.cc
@@ -18,8 +18,7 @@
 #include <fstream>
 #include <iostream>
 
-#include "fmt/format.h"
-#include "fmt/ostream.h"
+#include "absl/strings/str_format.h"
 
 #include "src/tools/argparser.h"
 #include "src/tools/text_errors.h"
@@ -54,7 +53,8 @@ namespace wasp {
 namespace tools {
 namespace wat2wasm {
 
-using fmt::print;
+using absl::PrintF;
+using absl::Format;
 
 struct Options {
   Features features;
@@ -74,7 +74,7 @@ struct Tool {
   SpanU8 data;
 };
 
-int Main(span<string_view> args) {
+int Main(span<const string_view> args) {
   string_view filename;
   Options options;
 
@@ -91,19 +91,19 @@ int Main(span<string_view> args) {
         if (filename.empty()) {
           filename = arg;
         } else {
-          print(std::cerr, "Filename already given\n");
+          Format(&std::cerr, "Filename already given\n");
         }
       });
   parser.Parse(args);
 
   if (filename.empty()) {
-    print(std::cerr, "No filenames given.\n");
+    Format(&std::cerr, "No filenames given.\n");
     parser.PrintHelpAndExit(1);
   }
 
   auto optbuf = ReadFile(filename);
   if (!optbuf) {
-    print(std::cerr, "Error reading file {}.\n", filename);
+    Format(&std::cerr, "Error reading file %s.\n", filename);
     return 1;
   }
 
@@ -156,7 +156,7 @@ int Tool::Run() {
   std::ofstream fstream(options.output_filename,
                         std::ios_base::out | std::ios_base::binary);
   if (!fstream) {
-    print(std::cerr, "Unable to open file {}.\n", options.output_filename);
+    Format(&std::cerr, "Unable to open file %s.\n", options.output_filename);
     return 1;
   }
 
diff --git a/src/tools/wat2wasm.h b/src/tools/wat2wasm.h
index c2771ceb..2d634609 100644
--- a/src/tools/wat2wasm.h
+++ b/src/tools/wat2wasm.h
@@ -22,7 +22,7 @@
 
 namespace wasp::tools::wat2wasm {
 
-int Main(span<string_view> args);
+int Main(span<const string_view> args);
 
 }  // namespace wasp::tools::wat2wasm
 
diff --git a/src/valid/types.cc b/src/valid/types.cc
index 1a2f6cc8..af169f04 100644
--- a/src/valid/types.cc
+++ b/src/valid/types.cc
@@ -21,7 +21,6 @@
 #include "wasp/base/hash.h"
 #include "wasp/base/macros.h"
 #include "wasp/base/operator_eq_ne_macros.h"
-#include "wasp/base/std_hash_macros.h"
 
 namespace wasp::valid {
 
@@ -260,6 +259,3 @@ WASP_VALID_STRUCTS_CUSTOM_FORMAT(WASP_OPERATOR_EQ_NE_VARGS)
 WASP_VALID_CONTAINERS(WASP_OPERATOR_EQ_NE_CONTAINER)
 
 }  // namespace wasp::valid
-
-WASP_VALID_STRUCTS_CUSTOM_FORMAT(WASP_STD_HASH_VARGS)
-WASP_VALID_CONTAINERS(WASP_STD_HASH_CONTAINER)
diff --git a/src/valid/validate_instruction.cc b/src/valid/validate_instruction.cc
index 0e803a06..5c30b58d 100644
--- a/src/valid/validate_instruction.cc
+++ b/src/valid/validate_instruction.cc
@@ -308,7 +308,7 @@ void PushTypes(Context& context, StackTypeSpan stack_types) {
 
 void RemovePrefixIfGreater(StackTypeSpan* lhs, StackTypeSpan rhs) {
   if (lhs->size() > rhs.size()) {
-    remove_prefix(lhs, lhs->size() - rhs.size());
+    lhs->remove_prefix(lhs->size() - rhs.size());
   }
 }
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 375bd6a7..fc3a6db5 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -31,7 +31,8 @@ target_include_directories(libwasp_test
 
 target_link_libraries(libwasp_test
   libwasp_base
-  libfmt
+  absl::raw_hash_set
+  absl::str_format
   gtest
 )
 
diff --git a/test/base/hash_test.cc b/test/base/hash_test.cc
index f3dccb74..8c76686a 100644
--- a/test/base/hash_test.cc
+++ b/test/base/hash_test.cc
@@ -28,10 +28,9 @@ struct S {
     return lhs.x == rhs.x && lhs.y == rhs.y;
   }
 
-  // Documentation says to use friend function named `hash_value`, but this
-  // only seems to work with a static function.
-  static size_t hash_value(const S& s) {
-    return HashState::combine(0, s.x, s.y);
+  template <typename H>
+  friend H AbslHashValue(H h, const S& s) {
+    return H::combine(std::move(h), s.x, s.y);
   }
 
   int x, y;
diff --git a/test/run_spec_tests.cc b/test/run_spec_tests.cc
index 1667b738..12081c68 100644
--- a/test/run_spec_tests.cc
+++ b/test/run_spec_tests.cc
@@ -20,8 +20,7 @@
 #include <iostream>
 #include <utility>
 
-#include "fmt/format.h"
-#include "fmt/ostream.h"
+#include "absl/strings/str_format.h"
 
 #include "src/tools/argparser.h"
 #include "src/tools/binary_errors.h"
@@ -42,7 +41,9 @@
 #include "wasp/valid/context.h"
 #include "wasp/valid/validate.h"
 
-using fmt::print;
+using absl::Format;
+using absl::PrintF;
+using absl::StrFormat;
 
 using namespace ::wasp;
 namespace fs = std::filesystem;
@@ -103,17 +104,14 @@ int main(int argc, char** argv) {
   tools::ArgParser parser{"run_spec_tests"};
   parser
       .Add('h', "--help", "print help and exit",
-           [&]() {
-             print(parser.GetHelpString());
-             exit(0);
-           })
+           [&]() { parser.PrintHelpAndExit(0); })
       .Add('v', "--verbose", "verbose output", [&]() { s_verbose++; })
       .Add("<filename>", "filename",
            [&](string_view arg) { filenames.push_back(arg); });
   parser.Parse(args);
 
   if (filenames.empty()) {
-    print(std::cerr, "No filename given.\n");
+    Format(&std::cerr, "No filename given.\n");
     return 1;
   }
 
@@ -145,7 +143,7 @@ int main(int argc, char** argv) {
 
     if (!enabled) {
       if (s_verbose) {
-        print("Skipping {}.\n", source.string());
+        PrintF("Skipping %s.\n", source.string());
       }
       continue;
     }
@@ -163,13 +161,13 @@ int main(int argc, char** argv) {
 
 void DoFile(const fs::path& path, const Features& features) {
   if (s_verbose) {
-    print("Reading {}...\n", path.string());
+    PrintF("Reading %s...\n", path.string());
   }
 
   std::string filename = path.string();
   auto data = ReadFile(filename);
   if (!data) {
-    print(std::cerr, "Error reading file {}", path.filename().string());
+    Format(&std::cerr, "Error reading file %s", path.filename().string());
     return;
   }
 
@@ -241,13 +239,13 @@ void Tool::OnAssertionCommand(text::Assertion& assertion) {
 
     if (assertion.kind == text::AssertionKind::Malformed) {
       if (script_module->kind == text::ScriptModuleKind::Quote) {
-        OnAssertMalformedText(
-            script_module.loc(),
-            fmt::format("malformed_{}.wat", assertion_count++), buffer);
+        OnAssertMalformedText(script_module.loc(),
+                              StrFormat("malformed_%d.wat", assertion_count++),
+                              buffer);
       } else {
         OnAssertMalformedBinary(
             script_module.loc(),
-            fmt::format("malformed_{}.wasm", assertion_count++), buffer);
+            StrFormat("malformed_%d.wasm", assertion_count++), buffer);
       }
     } else if (assertion.kind == text::AssertionKind::Invalid) {
       errors.OnError(script_module.loc(), "assert_invalid with quote/bin?");
diff --git a/test/text/lex_test.cc b/test/text/lex_test.cc
index 41f0b7f7..576c0276 100644
--- a/test/text/lex_test.cc
+++ b/test/text/lex_test.cc
@@ -1178,7 +1178,7 @@ R"((  module (; a comment ;) (  func  ) ) ))"_su8;
 
   for (auto&& pair : expected_tokens) {
     span = ExpectLex(pair.token, span);
-    remove_prefix(&span, pair.gap);
+    span.remove_prefix(pair.gap);
   }
 }
 
diff --git a/test/tools/argparser_test.cc b/test/tools/argparser_test.cc
index 47682e9d..95fd6096 100644
--- a/test/tools/argparser_test.cc
+++ b/test/tools/argparser_test.cc
@@ -144,7 +144,7 @@ TEST(ArgParserTest, UnknownBare) {
 }
 
 TEST(ArgParserTest, RestOfArgs) {
-  span<string_view> rest;
+  span<const string_view> rest;
 
   ArgParser parser{"prog"};
   parser.Add('a', "--a", "help", []() {})
diff --git a/third_party/CMakeLists.txt b/third_party/CMakeLists.txt
index fff3e971..5ea7d058 100644
--- a/third_party/CMakeLists.txt
+++ b/third_party/CMakeLists.txt
@@ -14,23 +14,7 @@
 # limitations under the License.
 #
 
-## fmt
-add_library(libfmt
-  fmt/src/format.cc
-)
-
-if (MSVC)
-  target_compile_options(libfmt
-    PRIVATE
-    /Zc:preprocessor-
-  )
-endif ()
-
-target_include_directories(libfmt
-  PUBLIC
-  ${wasp_SOURCE_DIR}/third_party/fmt/include
-)
-
+add_subdirectory(abseil)
 
 ## gtest
 if (BUILD_TESTING)
diff --git a/third_party/abseil b/third_party/abseil
new file mode 160000
index 00000000..e9b9e38f
--- /dev/null
+++ b/third_party/abseil
@@ -0,0 +1 @@
+Subproject commit e9b9e38f67a008d66133535a72ada843bd66013f
diff --git a/third_party/fmt b/third_party/fmt
deleted file mode 160000
index 9bdd1596..00000000
--- a/third_party/fmt
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 9bdd1596cef1b57b9556f8bef32dc4a32322ef3e
diff --git a/third_party/parallel-hashmap b/third_party/parallel-hashmap
deleted file mode 160000
index f84de40f..00000000
--- a/third_party/parallel-hashmap
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit f84de40fcd075415ad4bc1a95d5e1c46dbeaa526
diff --git a/third_party/span-lite b/third_party/span-lite
deleted file mode 160000
index e9e4491a..00000000
--- a/third_party/span-lite
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit e9e4491ad50a084c7f45f73dca61408a22e9e255