diff --git a/.gitignore b/.gitignore
index 7c9deb6..e91eb42 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
 .idea
 cmake-build*
 .DS_Store
+*.user
+build
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0d5dac4..5adfc2c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,21 +7,42 @@ cmake_minimum_required(VERSION 3.12)
 project(libstdaudio)
 
 set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
-
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -O0 -fsanitize=undefined")
 if (APPLE)
     set(CMAKE_EXE_LINKER_FLAGS "-framework CoreAudio")
 endif ()
 
+# add the headers to at least one target so that they get
+# parsed as part of the project in some IDEs
+set(headers
+    include/__audio_base.h
+    include/__audio_buffer.h
+    include/__audio_device.h
+    include/__audio_exception.h
+    include/__dynamic_library.h
+    include/audio
+    include/cpp/span.hpp
+    include/audio_backend/__coreaudio_backend.h
+    include/audio_backend/__null_backend.h
+    include/audio_backend/__portaudio_backend.h
+    include/audio_backend/__pulseaudio_backend.h
+    )
 include_directories(include)
 
-add_executable(white_noise examples/white_noise.cpp)
+add_executable(white_noise examples/white_noise.cpp ${headers})
+target_link_libraries(white_noise PRIVATE ${CMAKE_DL_LIBS})
 add_executable(print_devices examples/print_devices.cpp)
+target_link_libraries(print_devices PRIVATE ${CMAKE_DL_LIBS})
 add_executable(sine_wave examples/sine_wave.cpp)
+target_link_libraries(sine_wave PRIVATE ${CMAKE_DL_LIBS})
 add_executable(melody examples/melody.cpp)
+target_link_libraries(melody PRIVATE ${CMAKE_DL_LIBS})
 add_executable(level_meter examples/level_meter.cpp)
+target_link_libraries(level_meter PRIVATE ${CMAKE_DL_LIBS})
 
 add_executable(test
         test/test_main.cpp
       #  test/null_backend_test.cpp // TODO: fix linker error when uncommenting this one!
-        test/default_backend_test.cpp)
\ No newline at end of file
+        test/default_backend_test.cpp)
+
+target_link_libraries(test PRIVATE ${CMAKE_DL_LIBS})
diff --git a/examples/print_devices.cpp b/examples/print_devices.cpp
index 721ed2f..aee5c93 100644
--- a/examples/print_devices.cpp
+++ b/examples/print_devices.cpp
@@ -5,7 +5,7 @@
 
 #include <iostream>
 #include <audio>
-
+#include <cassert>
 using namespace std::experimental;
 
 void print_device_info(const audio_device& d) {
@@ -27,4 +27,4 @@ int main() {
 
   std::cout << "\nOutput devices:\n===============\n";
   print_device_list(get_audio_output_device_list());
-}
\ No newline at end of file
+}
diff --git a/include/__audio_base.h b/include/__audio_base.h
new file mode 100644
index 0000000..4586da1
--- /dev/null
+++ b/include/__audio_base.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <optional>
+#include <cassert>
+#include <string_view>
+#include <atomic>
+
+// TODO: this is a temporary measure until std::span becomes available
+#include "cpp/span.hpp"
+using namespace TCB_SPAN_NAMESPACE_NAME;
+
+#define _LIBSTDAUDIO_NAMESPACE std::experimental
+
+#define _LIBSTDAUDIO_NAMESPACE_BEGIN namespace _LIBSTDAUDIO_NAMESPACE {
+#define _LIBSTDAUDIO_NAMESPACE_END }
+
+_LIBSTDAUDIO_NAMESPACE_BEGIN
+
+struct audio_null_driver_t {};
+
+#ifdef __APPLE__
+  struct __coreaudio_driver_t {};
+  using audio_default_driver_t = __coreaudio_driver_t;
+#else
+
+#if __has_include(<pulse/pulseaudio.h>)
+  struct __pulseaudio_driver_t {};
+#endif
+#if __has_include(<portaudio.h>)
+  struct __portaudio_driver_t {};
+#endif
+
+#if __has_include(<pulse/pulseaudio.h>)
+  using audio_default_driver_t = __pulseaudio_driver_t;
+#elif __has_include(<portaudio.h>)
+  using audio_default_driver_t = __portaudio_driver_t;
+#endif
+#endif // __APPLE__
+
+_LIBSTDAUDIO_NAMESPACE_END
+
diff --git a/include/__audio_buffer.h b/include/__audio_buffer.h
index 99cb4ed..7e6b6d0 100644
--- a/include/__audio_buffer.h
+++ b/include/__audio_buffer.h
@@ -4,6 +4,7 @@
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
 #pragma once
+#include <__audio_base.h>
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
diff --git a/include/__audio_device.h b/include/__audio_device.h
index a45c8f9..7c766ff 100644
--- a/include/__audio_device.h
+++ b/include/__audio_device.h
@@ -4,6 +4,7 @@
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
 #pragma once
+#include <__audio_base.h>
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
diff --git a/include/__audio_exception.h b/include/__audio_exception.h
new file mode 100644
index 0000000..c8a90c8
--- /dev/null
+++ b/include/__audio_exception.h
@@ -0,0 +1,13 @@
+#pragma once
+#include <__audio_base.h>
+#include <stdexcept>
+
+_LIBSTDAUDIO_NAMESPACE_BEGIN
+
+struct audio_device_exception : public runtime_error {
+  explicit audio_device_exception(const char* what)
+    : runtime_error(what) {
+  }
+};
+
+_LIBSTDAUDIO_NAMESPACE_END
diff --git a/include/__dynamic_library.h b/include/__dynamic_library.h
new file mode 100644
index 0000000..35323e0
--- /dev/null
+++ b/include/__dynamic_library.h
@@ -0,0 +1,70 @@
+#pragma once
+#include <__audio_base.h>
+
+#if defined(_WIN32)
+#define __STDAUDIO_HAS_DYLIB 1
+#include <windows.h>
+#elif __has_include(<dlfcn.h>)
+#define __STDAUDIO_HAS_DYLIB 1
+#include <dlfcn.h>
+#endif
+
+_LIBSTDAUDIO_NAMESPACE_BEGIN
+#if __STDAUDIO_HAS_DYLIB
+class __dynamic_library
+{
+public:
+  explicit __dynamic_library(const char* const so) /* not noexcept - some DLL constructors can throw */
+  {
+#ifdef _WIN32
+    impl = (void*)LoadLibraryA(so);
+#else
+    impl = dlopen(so, RTLD_LAZY | RTLD_LOCAL | RTLD_NODELETE);
+#endif
+  }
+
+  __dynamic_library(const __dynamic_library&) noexcept = delete;
+  __dynamic_library& operator=(const __dynamic_library&) noexcept = delete;
+  __dynamic_library(__dynamic_library&& other)
+  {
+    impl = other.impl;
+    other.impl = nullptr;
+  }
+
+  __dynamic_library& operator=(__dynamic_library&& other) noexcept
+  {
+    impl = other.impl;
+    other.impl = nullptr;
+    return *this;
+  }
+
+  ~__dynamic_library()
+  {
+    if (impl)
+    {
+#ifdef _WIN32
+      FreeLibrary((HMODULE)impl);
+#else
+      dlclose(impl);
+#endif
+    }
+  }
+
+  template <typename T>
+  T symbol(const char* const sym) const noexcept
+  {
+#ifdef _WIN32
+    return (T)GetProcAddress((HMODULE)impl, sym);
+#else
+    return (T)dlsym(impl, sym);
+#endif
+  }
+
+  operator bool() const { return bool(impl); }
+
+private:
+  void* impl{};
+};
+#endif
+
+_LIBSTDAUDIO_NAMESPACE_END
diff --git a/include/audio b/include/audio
index b35f4b3..cc890ed 100644
--- a/include/audio
+++ b/include/audio
@@ -4,31 +4,7 @@
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
 #pragma once
-
-#include <optional>
-
-// TODO: this is a temporary measure until std::span becomes available
-#include "cpp/span.hpp"
-using namespace TCB_SPAN_NAMESPACE_NAME;
-
-#define _LIBSTDAUDIO_NAMESPACE std::experimental
-
-#define _LIBSTDAUDIO_NAMESPACE_BEGIN namespace _LIBSTDAUDIO_NAMESPACE {
-#define _LIBSTDAUDIO_NAMESPACE_END }
-
-_LIBSTDAUDIO_NAMESPACE_BEGIN
-
-struct audio_null_driver_t {};
-
-#ifdef __APPLE__
-  struct __coreaudio_driver_t {};
-  using audio_default_driver_t = __coreaudio_driver_t;
-#else
-  using audio_default_driver_t = audio_null_driver_t;
-#endif // __APPLE__
-
-_LIBSTDAUDIO_NAMESPACE_END
-
+#include <__audio_base.h>
 #include <__audio_buffer.h>
 #include <__audio_device.h>
 #include <audio_backend/__null_backend.h>
@@ -36,3 +12,9 @@ _LIBSTDAUDIO_NAMESPACE_END
 #ifdef __APPLE__
   #include <audio_backend/__coreaudio_backend.h>
 #endif // __APPLE__
+#if __has_include(<portaudio.h>)
+  #include <audio_backend/__portaudio_backend.h>
+#endif
+#if __has_include(<pulse/pulseaudio.h>)
+  #include <audio_backend/__pulseaudio_backend.h>
+#endif
diff --git a/include/audio_backend/__coreaudio_backend.h b/include/audio_backend/__coreaudio_backend.h
index 1ca7f4e..0899972 100644
--- a/include/audio_backend/__coreaudio_backend.h
+++ b/include/audio_backend/__coreaudio_backend.h
@@ -5,6 +5,10 @@
 
 #pragma once
 
+#include <__audio_base.h>
+#include <__audio_device.h>
+#include <__audio_buffer.h>
+#include <__audio_exception.h>
 #include <cctype>
 #include <string>
 #include <iostream>
@@ -72,12 +76,6 @@ class __coreaudio_util {
   }
 };
 
-struct audio_device_exception : public runtime_error {
-  explicit audio_device_exception(const char* what)
-    : runtime_error(what) {
-  }
-};
-
 using __coreaudio_device = audio_basic_device<__coreaudio_driver_t>;
 
 template<>
diff --git a/include/audio_backend/__null_backend.h b/include/audio_backend/__null_backend.h
index 04c5070..347f2cb 100644
--- a/include/audio_backend/__null_backend.h
+++ b/include/audio_backend/__null_backend.h
@@ -4,31 +4,90 @@
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
 #pragma once
-
+#include <forward_list>
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
 template<>
-class audio_basic_device<audio_null_driver_t> {};
+class audio_basic_device<audio_null_driver_t>
+{
+public:
+  audio_basic_device() = delete;
+
+  using sample_rate_t = double;
+  sample_rate_t get_sample_rate() const noexcept { return 0; }
+  bool set_sample_rate(sample_rate_t new_sample_rate) {
+    return false;
+  }
+
+  bool start() { return false; }
+  bool stop() { return false; }
+
+  using buffer_size_t = uint32_t;
+
+  buffer_size_t get_buffer_size_frames() const noexcept
+  {
+      return 0;
+  }
+
+  string_view name() const noexcept {
+      return {};
+  }
+
+  using device_id_t = int;
+  device_id_t device_id() const noexcept {
+    return -1;
+  }
+
+  bool is_input() const noexcept {
+    return false;
+  }
+
+  bool is_output() const noexcept {
+      return false;
+  }
+  int get_num_input_channels() const noexcept {
+    return 0;
+  }
+
+  int get_num_output_channels() const noexcept {
+    return 0;
+  }
 
+  template<typename T>
+  void connect(T) {
+
+  }
+
+  constexpr bool can_connect() const noexcept {
+    return false;
+  }
+
+  constexpr bool can_process() const noexcept {
+    return false;
+  }
+
+  constexpr bool is_running() const noexcept {
+    return false;
+  }
+
+  span<const sample_rate_t> get_supported_sample_rates() const noexcept {
+    return { };
+  }
+
+  span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
+      return { };
+  }
+
+  bool set_buffer_size_frames(buffer_size_t new_buffer_size) {
+    return false;
+  }
+
+};
+
+using __null_device = audio_basic_device<audio_null_driver_t>;
 template<>
-class audio_basic_device_list<audio_null_driver_t>
+class audio_basic_device_list<audio_null_driver_t> : public forward_list<__null_device>
 {
-private:
-  class iterator {
-  public:
-    auto operator==(const iterator&) const noexcept { return true; }
-    auto operator!=(const iterator&) const noexcept { return false; }
-    auto operator++() -> const iterator& { assert(false); return *this; }
-    auto operator*() -> audio_basic_device<audio_null_driver_t>& {
-      assert(false); static audio_basic_device<audio_null_driver_t> device{};
-      return device;
-    }
-  };
-
-public:
-  auto begin() -> iterator { return {}; }
-  auto end() -> iterator { return {}; }
-  auto empty() -> bool { return true; }
 };
 
 template<>
@@ -59,4 +118,4 @@ auto get_audio_output_device_list<audio_null_driver_t>()
   return {};
 }
 
-_LIBSTDAUDIO_NAMESPACE_END
\ No newline at end of file
+_LIBSTDAUDIO_NAMESPACE_END
diff --git a/include/audio_backend/__portaudio_backend.h b/include/audio_backend/__portaudio_backend.h
new file mode 100644
index 0000000..69afc91
--- /dev/null
+++ b/include/audio_backend/__portaudio_backend.h
@@ -0,0 +1,396 @@
+// libstdaudio
+// Copyright (c) 2019 - Jean-Michaël Celerier
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+#pragma once
+#include <__audio_base.h>
+#include <__audio_device.h>
+#include <__audio_buffer.h>
+#include <__dynamic_library.h>
+#include <__audio_exception.h>
+#include <forward_list>
+#include <functional>
+#include <cassert>
+#include <portaudio.h>
+
+// multi-API problem : can't e.g. initialize jack from itself, and also from portaudio
+
+_LIBSTDAUDIO_NAMESPACE_BEGIN
+
+class __portaudio_lib
+{
+public:
+    decltype(&::Pa_Initialize) initialize{}, actual_init{};
+    decltype(&::Pa_Terminate) terminate{}, actual_term{};
+    decltype(&::Pa_OpenStream) open_stream{};
+    decltype(&::Pa_StartStream) start_stream{};
+    decltype(&::Pa_CloseStream) close_stream{};
+    decltype(&::Pa_StopStream) stop_stream{};
+    decltype(&::Pa_IsStreamActive) is_stream_active{};
+    decltype(&::Pa_GetDeviceCount) get_device_count{};
+    decltype(&::Pa_GetDeviceInfo) get_device_info{};
+    decltype(&::Pa_GetDefaultInputDevice) get_default_input{};
+    decltype(&::Pa_GetDefaultOutputDevice) get_default_output{};
+    decltype(&::Pa_GetErrorText) get_error_text{};
+
+    static const __portaudio_lib& instance() {
+        static const __portaudio_lib self;
+        return self;
+    }
+
+
+    struct scoped_init_context {
+        const __portaudio_lib& library;
+        scoped_init_context(const __portaudio_lib& self)
+            : library{self}
+        {
+            auto err = library.initialize();
+            if(err != paNoError)
+                throw std::runtime_error("Cannot initialize portaudio device");
+        }
+
+        ~scoped_init_context()
+        {
+            library.terminate();
+        }
+    };
+
+    auto scoped_init() const
+    {
+        return scoped_init_context{*this};
+    }
+private:
+#if __STDAUDIO_HAS_DYLIB
+    __dynamic_library library;
+
+    __portaudio_lib()
+  #if defined(_WIN32)
+          :library("portaudio.dll")
+  #elif defined(__APPLE__)
+          :library("portaudio.dylib")
+  #else
+          :library("libportaudio.so")
+  #endif
+    {
+        actual_init = library.symbol<decltype(&::Pa_Initialize)>("Pa_Initialize");
+        actual_term = library.symbol<decltype(&::Pa_Terminate)>("Pa_Terminate");
+        initialize = [] {
+            return instance().actual_init();
+        };
+        terminate = [] {
+            return instance().actual_term();
+        };
+        open_stream = library.symbol<decltype(&::Pa_OpenStream)>("Pa_OpenStream");
+        start_stream = library.symbol<decltype(&::Pa_StartStream)>("Pa_StartStream");
+        close_stream = library.symbol<decltype(&::Pa_CloseStream)>("Pa_CloseStream");
+        stop_stream = library.symbol<decltype(&::Pa_StopStream)>("Pa_StopStream");
+        is_stream_active = library.symbol<decltype(&::Pa_IsStreamActive)>("Pa_IsStreamActive");
+        get_device_count = library.symbol<decltype(&::Pa_GetDeviceCount)>("Pa_GetDeviceCount");
+        get_device_info = library.symbol<decltype(&::Pa_GetDeviceInfo)>("Pa_GetDeviceInfo");
+        get_default_input = library.symbol<decltype(&::Pa_GetDefaultInputDevice)>("Pa_GetDefaultInputDevice");
+        get_default_output = library.symbol<decltype(&::Pa_GetDefaultOutputDevice)>("Pa_GetDefaultOutputDevice");
+        get_error_text = library.symbol<decltype(&::Pa_GetErrorText)>("Pa_GetErrorText");
+        assert(initialize);
+        assert(terminate);
+        assert(open_stream);
+        assert(start_stream);
+        assert(close_stream);
+        assert(stop_stream);
+        assert(is_stream_active);
+        assert(get_device_count);
+        assert(get_device_info);
+        assert(get_default_input);
+        assert(get_default_output);
+        assert(get_error_text);
+    }
+#else
+    __portaudio_lib()
+    {
+        initialize = &::Pa_Initialize;
+        terminate = &::__portaudio_lib::instance().terminate;
+        open_stream = &::Pa_OpenStream;
+        start_stream = &::Pa_StartStream;
+        close_stream = &::Pa_CloseStream;
+        stop_stream = &::Pa_StopStream;
+        is_stream_active = &::Pa_IsStreamActive;
+        get_device_count = &::Pa_GetDeviceCount;
+        get_device_info = &::Pa_GetDeviceInfo;
+        get_default_input = &::Pa_GetDefaultInputDevice;
+        get_default_output = &::Pa_GetDefaultOutputDevice;
+        get_error_text = &::Pa_GetErrorText;
+    }
+#endif
+};
+
+using __portaudio_device = audio_basic_device<__portaudio_driver_t>;
+// How to handle stuff like MME or pulseaudio where you can mix and match sound
+// cards ?
+template <> class audio_basic_device<__portaudio_driver_t> {
+  const PaDeviceInfo &m_info;
+  const int m_index;
+
+public:
+  audio_basic_device(const PaDeviceInfo &info, PaDeviceIndex device)
+      : m_info{info}, m_index{device} {
+    if (__portaudio_lib::instance().initialize() != paNoError) {
+      throw std::runtime_error("Cannot initialize portaudio device");
+    }
+
+    m_in.device = m_index;
+    m_in.channelCount = info.maxInputChannels;
+    m_in.sampleFormat = paFloat32; // Let's make that configurable later.
+    m_in.suggestedLatency = 1024. / info.defaultSampleRate;
+    m_in.hostApiSpecificStreamInfo = nullptr;
+
+    m_out.device = m_index;
+    m_out.channelCount = info.maxOutputChannels;
+    m_out.sampleFormat = paFloat32; // Let's make that configurable later.
+    m_out.suggestedLatency = 1024. / info.defaultSampleRate;
+    m_out.hostApiSpecificStreamInfo = nullptr;
+
+    m_sampleRate = m_info.defaultSampleRate;
+    m_frames = std::max(m_info.defaultHighInputLatency,
+                        m_info.defaultHighOutputLatency) *
+               m_sampleRate;
+  }
+
+  audio_basic_device(const audio_basic_device &other) = delete;
+  audio_basic_device(audio_basic_device &&other)
+      : audio_basic_device(other.m_info, other.m_index) {}
+
+  audio_basic_device &operator=(const audio_basic_device &) = delete;
+  audio_basic_device &operator=(audio_basic_device &&) = delete;
+  ~audio_basic_device() { __portaudio_lib::instance().terminate(); }
+
+  using sample_rate_t = double;
+
+  sample_rate_t get_sample_rate() const noexcept { return m_sampleRate; }
+
+  bool set_sample_rate(sample_rate_t new_sample_rate) {
+    const bool was_running = is_running();
+    if (was_running)
+      stop();
+    m_sampleRate = new_sample_rate;
+
+    if (was_running)
+      start();
+    return true;
+  }
+
+  bool start() {
+    if (is_running())
+      return false;
+
+    m_stream = nullptr;
+
+    PaStreamParameters *actualInput{};
+    if (m_in.device != paNoDevice && m_in.channelCount > 0)
+      actualInput = &m_in;
+
+    PaStreamParameters *actualOutput{};
+    if (m_out.device != paNoDevice && m_out.channelCount > 0)
+      actualOutput = &m_out;
+
+    // Another thing with portaudio is that you don't know the
+    // actual buffer size until it's running - and even then it's only an
+    // estimation
+    // - on some platforms it can vary per-tick
+    auto &pa = __portaudio_lib::instance();
+    auto err = pa.open_stream(&m_stream, actualInput, actualOutput,
+                              m_sampleRate, m_frames, paNoFlag, callback, this);
+    if (err != paNoError) {
+      //  std::cerr << pa.get_error_text(err) << "\n";
+      return false;
+    }
+    err = pa.start_stream(m_stream);
+    if (err != paNoError) {
+      pa.close_stream(m_stream);
+      m_stream = nullptr;
+      //  std::cerr << pa.get_error_text(err) << "\n";
+      return false;
+    }
+
+    return true;
+  }
+
+  bool stop() {
+    if (!is_running()) {
+      return false;
+    }
+    auto &pa = __portaudio_lib::instance();
+    auto err = pa.stop_stream(m_stream);
+    if (err != paNoError)
+      return false;
+
+    err = pa.close_stream(m_stream);
+    if (err != paNoError)
+      return false;
+
+    m_stream = nullptr;
+    return true;
+  }
+
+  using buffer_size_t = uint32_t;
+
+  buffer_size_t get_buffer_size_frames() const noexcept { return m_frames; }
+
+  string_view name() const noexcept { return m_info.name; }
+
+  using device_id_t = int;
+  device_id_t device_id() const noexcept { return -1; }
+
+  bool is_input() const noexcept { return m_in.channelCount > 0; }
+
+  bool is_output() const noexcept { return m_out.channelCount > 0; }
+
+  int get_num_input_channels() const noexcept { return m_in.channelCount; }
+
+  int get_num_output_channels() const noexcept { return m_out.channelCount; }
+
+  template <typename T> void connect(T t) {
+    // in my experience, it is sometimes necessary to swap callbacks at
+    // run-time. that's doable with some atomic operations.
+    if (is_running())
+      throw audio_device_exception("cannot connect to running audio_device");
+
+    m_callback = move(t);
+  }
+
+  constexpr bool can_connect() const noexcept { return true; }
+
+  constexpr bool can_process() const noexcept { return false; }
+
+  bool is_running() const noexcept {
+    auto &pa = __portaudio_lib::instance();
+    return m_stream && pa.is_stream_active(m_stream);
+  }
+
+  // Problem for this : depending on the API, it's a pair <sample rate, buffer
+  // size> which is supported.
+  span<const sample_rate_t> get_supported_sample_rates() const noexcept {
+    static constexpr std::array<sample_rate_t, 2> srs{44100., 48000.};
+    return {srs.data(), srs.size()};
+  }
+
+  span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
+    static constexpr std::array<buffer_size_t, 7> bs{
+        paFramesPerBufferUnspecified, 32, 64, 128, 256, 512, 1024};
+    return {bs.data(), bs.size()};
+  }
+
+  bool set_buffer_size_frames(buffer_size_t new_buffer_size) {
+    const bool was_running = is_running();
+    if (was_running)
+      stop();
+
+    m_frames = new_buffer_size;
+
+    if (was_running)
+      start();
+    return true;
+  }
+
+private:
+  double m_sampleRate{};
+  buffer_size_t m_frames{};
+  PaStreamParameters m_in{};
+  PaStreamParameters m_out{};
+  PaStream *m_stream{};
+
+  using __portaudio_callback_t =
+      function<void(__portaudio_device &, audio_device_buffers &)>;
+  __portaudio_callback_t m_callback;
+
+  static int callback(const void *input, void *output, unsigned long nframes,
+                      const PaStreamCallbackTimeInfo *timeInfo,
+                      PaStreamCallbackFlags statusFlags, void *userData) {
+    auto &self = *static_cast<audio_basic_device *>(userData);
+    if (self.m_callback) {
+      audio_device_buffers bufs;
+      // Right now most efficient way I know of doing conversions is using
+      // FFMPEG's libsamplerate. How would that fit in ?
+      using buffer_t =
+          audio_basic_buffer<float,
+                             std::experimental::audio_buffer_order_interleaved>;
+      if (input) {
+        // needs a const_cast here :x
+        buffer_t inb((float *)input, nframes * self.get_num_input_channels(),
+                     self.get_num_input_channels());
+        bufs.__input_buffer = inb;
+      }
+
+      if (output) {
+        buffer_t outb((float *)output, nframes * self.get_num_output_channels(),
+                      self.get_num_output_channels());
+        bufs.__output_buffer = outb;
+      }
+
+      self.m_callback(self, bufs);
+    }
+    return paNoError;
+  }
+};
+
+template <>
+class audio_basic_device_list<__portaudio_driver_t>
+    : public forward_list<__portaudio_device> {
+  const __portaudio_lib &library;
+  __portaudio_lib::scoped_init_context context;
+
+public:
+  audio_basic_device_list(bool init_inputs, bool init_outputs)
+      : library{__portaudio_lib::instance()}, context{library} {
+    for (PaDeviceIndex i = 0, n = library.get_device_count(); i < n; i++) {
+      try {
+        auto dev = library.get_device_info(i);
+        if (!dev)
+          continue;
+        if ((init_inputs && dev->maxInputChannels > 0) ||
+            (init_outputs && dev->maxOutputChannels > 0))
+          this->emplace_front(*dev, i);
+      } catch (...) {
+      }
+    }
+  }
+};
+
+template <>
+auto get_default_audio_input_device<__portaudio_driver_t>()
+    -> optional<audio_basic_device<__portaudio_driver_t>> {
+  auto &pa = __portaudio_lib::instance();
+  auto context = pa.scoped_init();
+  auto idx = pa.get_default_input();
+  auto dev = pa.get_device_info(idx);
+  if (dev) {
+    return audio_basic_device<__portaudio_driver_t>{*dev, idx};
+  }
+  return {};
+}
+
+template <>
+auto get_default_audio_output_device<__portaudio_driver_t>()
+    -> optional<audio_basic_device<__portaudio_driver_t>> {
+  auto &pa = __portaudio_lib::instance();
+  auto context = pa.scoped_init();
+  auto idx = pa.get_default_output();
+  auto dev = pa.get_device_info(idx);
+  if (dev) {
+    return audio_basic_device<__portaudio_driver_t>{*dev, idx};
+  }
+  return {};
+}
+
+template <>
+auto get_audio_input_device_list<__portaudio_driver_t>()
+    -> audio_basic_device_list<__portaudio_driver_t> {
+  return audio_basic_device_list<__portaudio_driver_t>{true, false};
+}
+
+template <>
+auto get_audio_output_device_list<__portaudio_driver_t>()
+    -> audio_basic_device_list<__portaudio_driver_t> {
+  return audio_basic_device_list<__portaudio_driver_t>{false, true};
+}
+
+_LIBSTDAUDIO_NAMESPACE_END
diff --git a/include/audio_backend/__pulseaudio_backend.h b/include/audio_backend/__pulseaudio_backend.h
new file mode 100644
index 0000000..d946713
--- /dev/null
+++ b/include/audio_backend/__pulseaudio_backend.h
@@ -0,0 +1,549 @@
+// libstdaudio
+// Copyright (c) 2019 - Jean-Michaël Celerier
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+#pragma once
+#include <__audio_base.h>
+#include <__audio_device.h>
+#include <__audio_buffer.h>
+#include <__dynamic_library.h>
+#include <__audio_exception.h>
+#include <forward_list>
+#include <functional>
+#include <string>
+#include <thread>
+#include <chrono>
+#include <cassert>
+#include <iostream>
+#include <pulse/pulseaudio.h>
+
+_LIBSTDAUDIO_NAMESPACE_BEGIN
+
+class __pulseaudio_lib
+{
+public:
+    decltype(&::pa_threaded_mainloop_new) pa_threaded_mainloop_new{};
+    decltype(&::pa_threaded_mainloop_free) pa_threaded_mainloop_free{};
+    decltype(&::pa_threaded_mainloop_get_api) pa_threaded_mainloop_get_api{};
+    decltype(&::pa_context_new) pa_context_new{};
+    decltype(&::pa_context_ref) pa_context_ref{};
+    decltype(&::pa_context_unref) pa_context_unref{};
+    decltype(&::pa_context_set_state_callback) pa_context_set_state_callback{};
+    decltype(&::pa_threaded_mainloop_lock) pa_threaded_mainloop_lock{};
+    decltype(&::pa_threaded_mainloop_unlock) pa_threaded_mainloop_unlock{};
+    decltype(&::pa_threaded_mainloop_start) pa_threaded_mainloop_start{};
+    decltype(&::pa_threaded_mainloop_stop) pa_threaded_mainloop_stop{};
+    decltype(&::pa_context_connect) pa_context_connect{};
+    decltype(&::pa_context_get_state) pa_context_get_state{};
+    decltype(&::pa_threaded_mainloop_wait) pa_threaded_mainloop_wait{};
+    decltype(&::pa_channel_map_init_stereo) pa_channel_map_init_stereo{};
+    decltype(&::pa_stream_new) pa_stream_new{};
+    decltype(&::pa_stream_new_with_proplist) pa_stream_new_with_proplist{};
+    decltype(&::pa_stream_ref) pa_stream_ref{};
+    decltype(&::pa_stream_unref) pa_stream_unref{};
+    decltype(&::pa_stream_get_state) pa_stream_get_state{};
+    decltype(&::pa_stream_set_state_callback) pa_stream_set_state_callback{};
+    decltype(&::pa_stream_set_write_callback) pa_stream_set_write_callback{};
+    decltype(&::pa_stream_set_read_callback) pa_stream_set_read_callback{};
+    decltype(&::pa_stream_set_overflow_callback) pa_stream_set_overflow_callback{};
+    decltype(&::pa_stream_connect_playback) pa_stream_connect_playback{};
+    decltype(&::pa_stream_cork) pa_stream_cork{};
+    decltype(&::pa_stream_is_corked) pa_stream_is_corked{};
+    decltype(&::pa_threaded_mainloop_signal) pa_threaded_mainloop_signal{};
+    decltype(&::pa_stream_begin_write) pa_stream_begin_write{};
+    decltype(&::pa_stream_write) pa_stream_write{};
+    decltype(&::pa_stream_set_name) pa_stream_set_name{};
+
+    static const __pulseaudio_lib& instance() {
+        static const __pulseaudio_lib self;
+        return self;
+    }
+
+private:
+#if __STDAUDIO_HAS_DYLIB
+    __dynamic_library library;
+
+    __pulseaudio_lib()
+        :library("libpulse.so")
+    {
+        // in terms of regex:
+        // decltype\(&::([a-z_]+)\) [a-z_]+{};
+        // \1 = library.symbol<decltype(&::\1)>("\1");
+
+        // we need reflection T_T
+        pa_threaded_mainloop_new = library.symbol<decltype(&::pa_threaded_mainloop_new)>("pa_threaded_mainloop_new");
+        pa_threaded_mainloop_free = library.symbol<decltype(&::pa_threaded_mainloop_free)>("pa_threaded_mainloop_free");
+        pa_threaded_mainloop_get_api = library.symbol<decltype(&::pa_threaded_mainloop_get_api)>("pa_threaded_mainloop_get_api");
+        pa_threaded_mainloop_lock = library.symbol<decltype(&::pa_threaded_mainloop_lock)>("pa_threaded_mainloop_lock");
+        pa_threaded_mainloop_unlock = library.symbol<decltype(&::pa_threaded_mainloop_lock)>("pa_threaded_mainloop_unlock");
+        pa_threaded_mainloop_start = library.symbol<decltype(&::pa_threaded_mainloop_start)>("pa_threaded_mainloop_start");
+        pa_threaded_mainloop_stop = library.symbol<decltype(&::pa_threaded_mainloop_stop)>("pa_threaded_mainloop_stop");
+        pa_threaded_mainloop_signal = library.symbol<decltype(&::pa_threaded_mainloop_signal)>("pa_threaded_mainloop_signal");
+        pa_context_new = library.symbol<decltype(&::pa_context_new)>("pa_context_new");
+        pa_context_ref = library.symbol<decltype(&::pa_context_ref)>("pa_context_ref");
+        pa_context_unref = library.symbol<decltype(&::pa_context_unref)>("pa_context_unref");
+        pa_context_set_state_callback = library.symbol<decltype(&::pa_context_set_state_callback)>("pa_context_set_state_callback");
+        pa_context_connect = library.symbol<decltype(&::pa_context_connect)>("pa_context_connect");
+        pa_context_get_state = library.symbol<decltype(&::pa_context_get_state)>("pa_context_get_state");
+        pa_threaded_mainloop_wait = library.symbol<decltype(&::pa_threaded_mainloop_wait)>("pa_threaded_mainloop_wait");
+        pa_channel_map_init_stereo = library.symbol<decltype(&::pa_channel_map_init_stereo)>("pa_channel_map_init_stereo");
+        pa_stream_new = library.symbol<decltype(&::pa_stream_new)>("pa_stream_new");
+        pa_stream_new_with_proplist = library.symbol<decltype(&::pa_stream_new_with_proplist)>("pa_stream_new_with_proplist");
+        pa_stream_ref = library.symbol<decltype(&::pa_stream_ref)>("pa_stream_ref");
+        pa_stream_unref = library.symbol<decltype(&::pa_stream_unref)>("pa_stream_unref");
+        pa_stream_get_state = library.symbol<decltype(&::pa_stream_get_state)>("pa_stream_get_state");
+        pa_stream_set_state_callback = library.symbol<decltype(&::pa_stream_set_state_callback)>("pa_stream_set_state_callback");
+        pa_stream_set_write_callback = library.symbol<decltype(&::pa_stream_set_write_callback)>("pa_stream_set_write_callback");
+        pa_stream_set_read_callback = library.symbol<decltype(&::pa_stream_set_read_callback)>("pa_stream_set_read_callback");
+        pa_stream_set_overflow_callback = library.symbol<decltype(&::pa_stream_set_overflow_callback)>("pa_stream_set_overflow_callback");
+        pa_stream_connect_playback = library.symbol<decltype(&::pa_stream_connect_playback)>("pa_stream_connect_playback");
+        pa_stream_cork = library.symbol<decltype(&::pa_stream_cork)>("pa_stream_cork");
+        pa_stream_is_corked = library.symbol<decltype(&::pa_stream_is_corked)>("pa_stream_is_corked");
+        pa_stream_begin_write = library.symbol<decltype(&::pa_stream_begin_write)>("pa_stream_begin_write");
+        pa_stream_write = library.symbol<decltype(&::pa_stream_write)>("pa_stream_write");
+        pa_stream_set_name = library.symbol<decltype(&::pa_stream_set_name)>("pa_stream_set_name");
+
+
+        // in terms of regex:
+        // decltype\(&::([a-z_]+)\) [a-z_]+{};
+        // assert(\1);
+        assert(pa_threaded_mainloop_new);
+        assert(pa_threaded_mainloop_free);
+        assert(pa_threaded_mainloop_get_api);
+        assert(pa_threaded_mainloop_lock);
+        assert(pa_threaded_mainloop_unlock);
+        assert(pa_threaded_mainloop_start);
+        assert(pa_threaded_mainloop_stop);
+        assert(pa_threaded_mainloop_signal);
+        assert(pa_context_new);
+        assert(pa_context_ref);
+        assert(pa_context_unref);
+        assert(pa_context_set_state_callback);
+        assert(pa_context_connect);
+        assert(pa_context_get_state);
+        assert(pa_threaded_mainloop_wait);
+        assert(pa_channel_map_init_stereo);
+        assert(pa_stream_new);
+        assert(pa_stream_new_with_proplist);
+        assert(pa_stream_ref);
+        assert(pa_stream_unref);
+        assert(pa_stream_get_state);
+        assert(pa_stream_set_state_callback);
+        assert(pa_stream_set_write_callback);
+        assert(pa_stream_set_read_callback);
+        assert(pa_stream_set_overflow_callback);
+        assert(pa_stream_connect_playback);
+        assert(pa_stream_cork);
+        assert(pa_stream_is_corked);
+        assert(pa_stream_begin_write);
+        assert(pa_stream_write);
+        assert(pa_stream_set_name);
+    }
+#else
+    __pulseaudio_lib()
+    {
+        // in terms of regex:
+        // decltype\(&::([a-z_]+)\) [a-z_]+{};
+        // \1 = &::\1;
+
+        pa_threaded_mainloop_new = &::pa_threaded_mainloop_new;
+        pa_threaded_mainloop_free = &::pa_threaded_mainloop_free;
+        pa_threaded_mainloop_get_api = &::pa_threaded_mainloop_get_api;
+        pa_threaded_mainloop_lock = &::pa_threaded_mainloop_lock;
+        pa_threaded_mainloop_unlock = &::pa_threaded_mainloop_unlock;
+        pa_threaded_mainloop_start = &::pa_threaded_mainloop_start;
+        pa_threaded_mainloop_stop = &::pa_threaded_mainloop_stop;
+        pa_threaded_mainloop_signal = &::pa_threaded_mainloop_signal;
+        pa_context_new = &::pa_context_new;
+        pa_context_ref = &::pa_context_ref;
+        pa_context_unref = &::pa_context_unref;
+        pa_context_connect = &::pa_context_connect;
+        pa_context_get_state = &::pa_context_get_state;
+        pa_context_set_state_callback = &::pa_context_set_state_callback;
+        pa_threaded_mainloop_wait = &::pa_threaded_mainloop_wait;
+        pa_channel_map_init_stereo = &::pa_channel_map_init_stereo;
+        pa_stream_new = &::pa_stream_new;
+        pa_stream_new_with_proplist = &::pa_stream_new_with_proplist;
+        pa_stream_ref = &::pa_stream_ref;
+        pa_stream_unref = &::pa_stream_unref;
+        pa_stream_get_state = &::pa_stream_get_state;
+        pa_stream_set_state_callback = &::pa_stream_set_state_callback;
+        pa_stream_set_write_callback = &::pa_stream_set_write_callback;
+        pa_stream_set_read_callback = &::pa_stream_set_read_callback;
+        pa_stream_set_overflow_callback = &::pa_stream_set_overflow_callback;
+        pa_stream_connect_playback = &::pa_stream_connect_playback;
+        pa_stream_cork = &::pa_stream_cork;
+        pa_stream_is_corked = &::pa_stream_is_corked;
+        pa_stream_begin_write = &::pa_stream_begin_write;
+        pa_stream_write = &::pa_stream_write;
+        pa_stream_set_name = &::pa_stream_set_name;
+    }
+#endif
+};
+
+using __pulseaudio_device = audio_basic_device<__pulseaudio_driver_t>;
+// How to handle stuff like MME or pulseaudio where you can mix and match sound
+// cards ?
+template <> class audio_basic_device<__pulseaudio_driver_t> {
+public:
+  audio_basic_device() noexcept {
+    m_sampleRate = 44100;
+    m_frames = 512;
+    m_name = "My app";
+  }
+
+  audio_basic_device(const audio_basic_device &other) = delete;
+  audio_basic_device(audio_basic_device &&other) noexcept
+      : m_sampleRate(other.m_sampleRate), m_frames(other.m_frames),
+        m_mainloop(other.m_mainloop), m_api(other.m_api),
+        m_context(other.m_context), m_stream(other.m_stream),
+        m_callback(std::move(other.m_callback)) {
+    other.m_mainloop = nullptr;
+    other.m_api = nullptr;
+    other.m_context = nullptr;
+    other.m_stream = nullptr;
+  }
+
+  audio_basic_device &operator=(const audio_basic_device &) = delete;
+  audio_basic_device &operator=(audio_basic_device &&) = delete;
+  ~audio_basic_device() { stop(); }
+
+  using sample_rate_t = double;
+
+  sample_rate_t get_sample_rate() const noexcept { return m_sampleRate; }
+
+  bool set_sample_rate(sample_rate_t new_sample_rate) {
+    const bool was_running = is_running();
+    if (was_running)
+      stop();
+    m_sampleRate = new_sample_rate;
+
+    if (was_running)
+      start();
+    return true;
+  }
+
+  bool start() {
+    if (is_running())
+      return false;
+
+    const auto &pa = __pulseaudio_lib::instance();
+
+    m_mainloop = pa.pa_threaded_mainloop_new();
+    if (!m_mainloop) {
+      // let's switch to Either or Outcome shall we :-)
+      throw audio_device_exception("Cannot initialize pulseaudio main loop");
+    }
+
+    m_api = pa.pa_threaded_mainloop_get_api(m_mainloop);
+    if (!m_api) {
+      throw audio_device_exception("Cannot initialize pulseaudio mainloop API");
+    }
+
+    // both for pulseaudio, and for JACK, instead of requesting a device,
+    // you declare your app as being a device which will be a piece of the
+    // audio graph - so there should be an API to set its name in that graph.
+    m_context = pa.pa_context_new(m_api, m_name.data());
+    if (!m_context) {
+      throw audio_device_exception("Cannot initialize pulseaudio context");
+    }
+
+    auto context_callback = [](pa_context *, void *mainloop) {
+      auto &pa = __pulseaudio_lib::instance();
+      pa.pa_threaded_mainloop_signal((pa_threaded_mainloop *)mainloop, 0);
+    };
+    pa.pa_context_set_state_callback(m_context, context_callback, m_mainloop);
+
+    pa.pa_threaded_mainloop_lock(m_mainloop);
+
+    if (auto err = pa.pa_threaded_mainloop_start(m_mainloop); err != 0) {
+      throw audio_device_exception("Cannot start pulseaudio main loop");
+    }
+    if (auto err = pa.pa_context_connect(m_context, nullptr,
+                                         PA_CONTEXT_NOAUTOSPAWN, nullptr);
+        err != 0) {
+      throw audio_device_exception("Cannot conntext the pulseaudio context");
+    }
+
+    // Wait until everything is ready - completely arbitrary timeout, maybe this
+    // should be settable
+    static const constexpr auto default_timeout = 3s;
+    {
+      auto t0 = chrono::steady_clock::now();
+      bool timeout = false;
+      while ((timeout = (chrono::steady_clock::now() - t0 < default_timeout))) {
+        switch (pa.pa_context_get_state(m_context)) {
+        case PA_CONTEXT_CONNECTING:
+        case PA_CONTEXT_AUTHORIZING:
+        case PA_CONTEXT_SETTING_NAME:
+          pa.pa_threaded_mainloop_wait(m_mainloop);
+          continue;
+
+        case PA_CONTEXT_READY:
+          break;
+
+        case PA_CONTEXT_FAILED:
+        case PA_CONTEXT_TERMINATED:
+        default:
+          throw audio_device_exception("Invalid context state");
+        }
+      }
+
+      if (timeout) {
+        throw audio_device_exception("Context creation timeout");
+      }
+    }
+
+
+    /// Everything from the beginning of start() to this point should
+    /// actually go in a context object which is not part of the device.
+    /// (A bit like Pa_Initialize() / Pa_Terminate() for portaudio)
+
+    pa_sample_spec sample_specifications;
+    sample_specifications.format = PA_SAMPLE_FLOAT32LE;
+
+    // for pulseaudio, samplerate is an uint
+    sample_specifications.rate = m_sampleRate;
+
+    // in pulse and JACK we ask how many channels we want ; in addition to Jack,
+    // pulse does intelligent resampling / upmixing / downmixing
+    sample_specifications.channels = 2;
+
+    pa_channel_map map;
+    pa.pa_channel_map_init_stereo(&map);
+
+    m_stream =
+        pa.pa_stream_new(m_context, "My stream", &sample_specifications, &map);
+    if (!m_stream) {
+      throw audio_device_exception("Cannot initialize pulseaudio stream");
+    }
+
+    const auto stream_cb = [](pa_stream *s, void *mainloop) {
+      auto &pa = __pulseaudio_lib::instance();
+      pa.pa_threaded_mainloop_signal((pa_threaded_mainloop *)mainloop, 0);
+    };
+    pa.pa_stream_set_state_callback(m_stream, stream_cb, m_mainloop);
+    pa.pa_stream_set_write_callback(m_stream, output_callback, this);
+
+    // Don't set values here, instead the server will provide what it judges to
+    // be the best.
+    pa_buffer_attr buffer_attr;
+    buffer_attr.maxlength = m_frames * sizeof(float) * get_num_output_channels();
+    buffer_attr.tlength = m_frames * sizeof(float) * get_num_output_channels();
+    buffer_attr.prebuf = (uint32_t)-1;
+    buffer_attr.minreq = 0;
+
+    const auto stream_flags = static_cast<pa_stream_flags_t>(
+        PA_STREAM_START_CORKED | PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_NOT_MONOTONIC |
+        PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_ADJUST_LATENCY);
+
+    // Connect stream to the default audio output sink
+    if (auto err = pa.pa_stream_connect_playback(
+            m_stream, nullptr, &buffer_attr, stream_flags, nullptr, nullptr);
+        err != 0) {
+      throw audio_device_exception("Cannot start pulseaudio stream");
+    }
+
+    {
+      auto t0 = chrono::steady_clock::now();
+      bool timeout = false;
+      while ((timeout = (chrono::steady_clock::now() - t0 < default_timeout))) {
+        switch (pa.pa_stream_get_state(m_stream)) {
+        case PA_STREAM_CREATING:
+          pa.pa_threaded_mainloop_wait(m_mainloop);
+          break;
+        case PA_STREAM_READY:
+          break;
+        default:
+          throw audio_device_exception("Invalid stream state");
+        }
+      }
+
+      if (timeout) {
+        throw audio_device_exception("Stream creation timeout");
+      }
+    }
+
+    pa.pa_threaded_mainloop_unlock(m_mainloop);
+
+    // cork means pausing, cork = 0 means resuming
+    pa.pa_stream_cork(m_stream, 0, success_cb, this);
+
+    return true;
+  }
+
+  bool stop() {
+    if (!is_running()) {
+      return false;
+    }
+
+    auto &pa = __pulseaudio_lib::instance();
+    pa.pa_stream_unref(m_stream);
+    m_stream = nullptr;
+    pa.pa_context_unref(m_context);
+    m_context = nullptr;
+    pa.pa_threaded_mainloop_free(m_mainloop);
+    m_mainloop = nullptr;
+    m_api = nullptr;
+    m_stream = nullptr;
+    return true;
+  }
+
+  using buffer_size_t = uint32_t;
+
+  buffer_size_t get_buffer_size_frames() const noexcept { return m_frames; }
+
+  string_view name() const noexcept { return m_name; }
+
+  using device_id_t = int;
+  device_id_t device_id() const noexcept { return -1; }
+
+  bool is_input() const noexcept { return true; }
+
+  bool is_output() const noexcept { return true; }
+
+  int get_num_input_channels() const noexcept { return 0; }
+
+  int get_num_output_channels() const noexcept { return 2; }
+
+  template <typename T> void connect(T t) {
+    // in my experience, it is sometimes necessary to swap callbacks at
+    // run-time. that's doable with some atomic operations.
+    if (is_running())
+      throw audio_device_exception("cannot connect to running audio_device");
+
+    m_callback = move(t);
+  }
+
+  constexpr bool can_connect() const noexcept { return true; }
+
+  constexpr bool can_process() const noexcept { return false; }
+
+  bool is_running() const noexcept {
+    auto &pa = __pulseaudio_lib::instance();
+    return m_stream && pa.pa_stream_is_corked(m_stream);
+  }
+
+  // you can put whatever samplerate you want with pulseaudio.
+  span<const sample_rate_t> get_supported_sample_rates() const noexcept {
+    static constexpr std::array<sample_rate_t, 2> srs{44100., 48000.};
+    return {srs.data(), srs.size()};
+  }
+
+  //  you can put whatever buffersize you want with pulseaudio (and it won't generally be respected anyways)
+  span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
+    static constexpr std::array<buffer_size_t, 6> bs{32,  64,  128,
+                                                     256, 512, 1024};
+    return {bs.data(), bs.size()};
+  }
+
+  bool set_buffer_size_frames(buffer_size_t new_buffer_size) {
+    const bool was_running = is_running();
+    if (was_running)
+      stop();
+
+    m_frames = new_buffer_size;
+
+    if (was_running)
+      start();
+    return true;
+  }
+
+private:
+  static void output_callback(pa_stream *stream, size_t requested_bytes,
+                              void *userdata) {
+    auto &pa = __pulseaudio_lib::instance();
+    auto &self = *static_cast<audio_basic_device *>(userdata);
+    float *buffer = nullptr;
+    size_t bytes_to_fill = requested_bytes;
+
+    do {
+      if (auto res = pa.pa_stream_begin_write(stream, (void **)&buffer,
+                                              &bytes_to_fill);
+          res != 0) {
+        // we're in huge trouble
+        return;
+      }
+
+      const auto size =
+          bytes_to_fill / (sizeof(float) * self.get_num_output_channels());
+      {
+        if (self.m_callback) {
+          audio_device_buffers bufs;
+          // Pulseaudio entirely separates input and playback
+          // so to have a full duplex callback, it needs to be buffered instead
+          using buffer_t = audio_basic_buffer<
+              float, std::experimental::audio_buffer_order_interleaved>;
+
+          buffer_t outb((float *)buffer, size * self.get_num_output_channels(),
+                        self.get_num_output_channels());
+          bufs.__output_buffer = outb;
+
+          self.m_callback(self, bufs);
+        }
+      }
+
+      if (auto res = pa.pa_stream_write(stream, buffer, bytes_to_fill, nullptr,
+                                        0LL, PA_SEEK_RELATIVE);
+          res != 0) {
+        // we're in huge trouble
+        return;
+      }
+
+      requested_bytes -= bytes_to_fill;
+      bytes_to_fill = requested_bytes;
+    } while (requested_bytes > 0);
+  }
+
+  static void success_cb(pa_stream *, int, void *) {}
+
+  std::string m_name;
+  double m_sampleRate{};
+  buffer_size_t m_frames{};
+
+  pa_threaded_mainloop *m_mainloop{};
+  pa_mainloop_api *m_api{};
+  pa_context *m_context{};
+  pa_stream *m_stream{};
+
+  using __pulseaudio_callback_t =
+      function<void(__pulseaudio_device &, audio_device_buffers &)>;
+  __pulseaudio_callback_t m_callback;
+};
+
+template<>
+class audio_basic_device_list<__pulseaudio_driver_t> : public forward_list<__pulseaudio_device>
+{
+public:
+    audio_basic_device_list()
+    {
+        this->emplace_front(__pulseaudio_device{});
+    }
+};
+
+template <>
+auto get_default_audio_input_device<__pulseaudio_driver_t>()
+    -> optional<audio_basic_device<__pulseaudio_driver_t>> {
+  return __pulseaudio_device{};
+}
+
+template <>
+auto get_default_audio_output_device<__pulseaudio_driver_t>()
+    -> optional<audio_basic_device<__pulseaudio_driver_t>> {
+  return __pulseaudio_device{};
+}
+
+template <>
+auto get_audio_input_device_list<__pulseaudio_driver_t>()
+    -> audio_basic_device_list<__pulseaudio_driver_t> {
+  return {};
+}
+
+template <>
+auto get_audio_output_device_list<__pulseaudio_driver_t>()
+    -> audio_basic_device_list<__pulseaudio_driver_t> {
+  return {};
+}
+
+_LIBSTDAUDIO_NAMESPACE_END