diff --git a/core/include/blue/core/stream.h b/core/include/blue/core/stream.h
new file mode 100644
index 0000000..a6881c3
--- /dev/null
+++ b/core/include/blue/core/stream.h
@@ -0,0 +1,102 @@
+#ifndef BLUELIB_CORE_STREAM_H_
+#define BLUELIB_CORE_STREAM_H_
+
+#include <blue/core/misc.h>
+#include <blue/core/status.h>
+#include <stdarg.h>
+
+#define b_stdin  (z__b_stream_get_stdin())
+#define b_stdout (z__b_stream_get_stdout())
+#define b_stderr (z__b_stream_get_stderr())
+
+typedef enum b_stream_pipeline_flags {
+	B_STREAM_PIPELINE_F_NONE = 0x00u,
+	B_STREAM_PIPELINE_F_DYNAMIC = 0x01u,
+	B_STREAM_PIPELINE_F_BUF_DYNAMIC = 0x02u,
+} b_stream_pipeline_flags;
+
+typedef struct b_stream_pipeline {
+	b_stream_pipeline_flags p_flags;
+	void *p_buf;
+	size_t p_buf_len;
+} b_stream_pipeline;
+
+typedef enum b_stream_mode {
+	B_STREAM_READ = 0x01u,
+	B_STREAM_WRITE = 0x02u,
+	B_STREAM_BINARY = 0x10u,
+	Z__B_STREAM_STATIC = 0x80u,
+} b_stream_mode;
+
+typedef enum b_stream_seek_origin {
+	B_STREAM_SEEK_START = 0x01u,
+	B_STREAM_SEEK_CURRENT = 0x02u,
+	B_STREAM_SEEK_END = 0x03u,
+} b_stream_seek_origin;
+
+typedef struct b_stream {
+	b_stream_mode s_mode;
+	size_t s_cursor;
+	int *s_istack;
+	int s_add_indent;
+	size_t s_istack_ptr, s_istack_size;
+	void *s_ptr;
+
+	b_status (*s_close)(struct b_stream *);
+	b_status (*s_seek)(struct b_stream *, long long, b_stream_seek_origin);
+	b_status (*s_getc)(struct b_stream *, int *);
+	b_status (*s_read)(struct b_stream *, unsigned char *, size_t, size_t *);
+	b_status (*s_write)(
+		struct b_stream *, const unsigned char *, size_t, size_t *);
+	b_status (*s_reserve)(struct b_stream *, size_t);
+} b_stream;
+
+BLUE_API b_stream *z__b_stream_get_stdin(void);
+BLUE_API b_stream *z__b_stream_get_stdout(void);
+BLUE_API b_stream *z__b_stream_get_stderr(void);
+
+BLUE_API b_status b_stream_pipeline_create(
+	size_t buffer_size, b_stream_pipeline **out);
+
+BLUE_API b_status b_stream_pipeline_create(
+	size_t buffer_size, b_stream_pipeline **out);
+BLUE_API b_status b_stream_pipeline_init(
+	void *p, size_t len, b_stream_pipeline *out);
+BLUE_API b_status b_stream_pipeline_destroy(b_stream_pipeline *pipeline);
+
+BLUE_API b_status b_stream_close(b_stream *stream);
+BLUE_API b_status b_stream_reserve(b_stream *stream, size_t len);
+BLUE_API b_status b_stream_seek(
+	b_stream *stream, long long offset, b_stream_seek_origin origin);
+BLUE_API size_t b_stream_cursor(const b_stream *stream);
+
+BLUE_API b_status b_stream_push_indent(b_stream *stream, int indent);
+BLUE_API b_status b_stream_pop_indent(b_stream *stream);
+
+BLUE_API b_status b_stream_read_char(b_stream *stream, int *c);
+
+BLUE_API b_status b_stream_read_bytes(
+	b_stream *stream, void *buf, size_t count, size_t *nr_read);
+
+BLUE_API b_status b_stream_read_line(b_stream *stream, char *s, size_t max);
+BLUE_API b_status b_stream_read_line_s(b_stream *src, b_stream *dest);
+
+BLUE_API b_status b_stream_read_all_bytes(
+	b_stream *stream, void *p, size_t max, size_t *nr_read);
+BLUE_API b_status b_stream_read_all_bytes_s(
+	b_stream *src, b_stream *dest, b_stream_pipeline *pipeline,
+	size_t *nr_read);
+
+BLUE_API b_status b_stream_write_char(b_stream *stream, char c);
+BLUE_API b_status b_stream_write_string(
+	b_stream *stream, const char *s, size_t *nr_written);
+
+BLUE_API b_status b_stream_write_bytes(
+	b_stream *stream, void *buf, size_t count, size_t *nr_written);
+
+BLUE_API b_status b_stream_write_fmt(
+	b_stream *stream, size_t *nr_written, const char *format, ...);
+BLUE_API b_status b_stream_write_vfmt(
+	b_stream *stream, size_t *nr_written, const char *format, va_list arg);
+
+#endif
diff --git a/core/printf.c b/core/printf.c
new file mode 100644
index 0000000..662a1f1
--- /dev/null
+++ b/core/printf.c
@@ -0,0 +1,957 @@
+///////////////////////////////////////////////////////////////////////////////
+// \author (c) Marco Paland (info@paland.com)
+//             2014-2019, PALANDesign Hannover, Germany
+//
+// \license The MIT License (MIT)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// \brief Tiny printf, sprintf and (v)snprintf implementation, optimized for speed on
+//        embedded systems with a very limited resources. These routines are thread
+//        safe and reentrant!
+//        Use this instead of the bloated standard/newlib printf cause these use
+//        malloc for printf (and may not be thread safe).
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "printf.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+// define this globally (e.g. gcc -DPRINTF_INCLUDE_CONFIG_H ...) to include the
+// printf_config.h header file
+// default: undefined
+#ifdef PRINTF_INCLUDE_CONFIG_H
+#include "printf_config.h"
+#endif
+
+// 'ntoa' conversion buffer size, this must be big enough to hold one converted
+// numeric number including padded zeros (dynamically created on stack)
+// default: 32 byte
+#ifndef PRINTF_NTOA_BUFFER_SIZE
+#define PRINTF_NTOA_BUFFER_SIZE 32U
+#endif
+
+// 'ftoa' conversion buffer size, this must be big enough to hold one converted
+// float number including padded zeros (dynamically created on stack)
+// default: 32 byte
+#ifndef PRINTF_FTOA_BUFFER_SIZE
+#define PRINTF_FTOA_BUFFER_SIZE 32U
+#endif
+
+// support for the floating point type (%f)
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_FLOAT
+#define PRINTF_SUPPORT_FLOAT
+#endif
+
+// support for exponential floating point notation (%e/%g)
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_EXPONENTIAL
+#define PRINTF_SUPPORT_EXPONENTIAL
+#endif
+
+// define the default floating point precision
+// default: 6 digits
+#ifndef PRINTF_DEFAULT_FLOAT_PRECISION
+#define PRINTF_DEFAULT_FLOAT_PRECISION 6U
+#endif
+
+// define the largest float suitable to print with %f
+// default: 1e9
+#ifndef PRINTF_MAX_FLOAT
+#define PRINTF_MAX_FLOAT 1e9
+#endif
+
+// support for the long long types (%llu or %p)
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_LONG_LONG
+#define PRINTF_SUPPORT_LONG_LONG
+#endif
+
+// support for the ptrdiff_t type (%t)
+// ptrdiff_t is normally defined in <stddef.h> as long or long long type
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_PTRDIFF_T
+#define PRINTF_SUPPORT_PTRDIFF_T
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+// internal flag definitions
+#define FLAGS_ZEROPAD   (1U << 0U)
+#define FLAGS_LEFT      (1U << 1U)
+#define FLAGS_PLUS      (1U << 2U)
+#define FLAGS_SPACE     (1U << 3U)
+#define FLAGS_HASH      (1U << 4U)
+#define FLAGS_UPPERCASE (1U << 5U)
+#define FLAGS_CHAR      (1U << 6U)
+#define FLAGS_SHORT     (1U << 7U)
+#define FLAGS_LONG      (1U << 8U)
+#define FLAGS_LONG_LONG (1U << 9U)
+#define FLAGS_PRECISION (1U << 10U)
+#define FLAGS_ADAPT_EXP (1U << 11U)
+
+// import float.h for DBL_MAX
+#if defined(PRINTF_SUPPORT_FLOAT)
+#include <float.h>
+#endif
+
+// output function type
+typedef void (*out_fct_type)(
+	char character, void *buffer, size_t idx, size_t maxlen);
+
+// wrapper (used as buffer) for output function type
+typedef struct {
+	void (*fct)(char character, void *arg);
+	void *arg;
+} out_fct_wrap_type;
+
+// internal buffer output
+static inline void _out_buffer(
+	char character, void *buffer, size_t idx, size_t maxlen)
+{
+	if (idx < maxlen) {
+		((char *)buffer)[idx] = character;
+	}
+}
+
+// internal null output
+static inline void _out_null(char character, void *buffer, size_t idx, size_t maxlen)
+{
+	(void)character;
+	(void)buffer;
+	(void)idx;
+	(void)maxlen;
+}
+
+// internal output function wrapper
+static inline void _out_fct(char character, void *buffer, size_t idx, size_t maxlen)
+{
+	(void)idx;
+	(void)maxlen;
+	if (character) {
+		// buffer is the output fct pointer
+		((out_fct_wrap_type *)buffer)
+			->fct(character, ((out_fct_wrap_type *)buffer)->arg);
+	}
+}
+
+// internal secure strlen
+// \return The length of the string (excluding the terminating 0) limited by 'maxsize'
+static inline unsigned int _strnlen_s(const char *str, size_t maxsize)
+{
+	const char *s;
+	for (s = str; *s && maxsize--; ++s)
+		;
+	return (unsigned int)(s - str);
+}
+
+// internal test if char is a digit (0-9)
+// \return true if char is a digit
+static inline bool _is_digit(char ch)
+{
+	return (ch >= '0') && (ch <= '9');
+}
+
+// internal ASCII string to unsigned int conversion
+static unsigned int _atoi(const char **str)
+{
+	unsigned int i = 0U;
+	while (_is_digit(**str)) {
+		i = i * 10U + (unsigned int)(*((*str)++) - '0');
+	}
+	return i;
+}
+
+// output the specified string in reverse, taking care of any zero-padding
+static size_t _out_rev(
+	out_fct_type out, char *buffer, size_t idx, size_t maxlen,
+	const char *buf, size_t len, unsigned int width, unsigned int flags)
+{
+	const size_t start_idx = idx;
+
+	// pad spaces up to given width
+	if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) {
+		for (size_t i = len; i < width; i++) {
+			out(' ', buffer, idx++, maxlen);
+		}
+	}
+
+	// reverse string
+	while (len) {
+		out(buf[--len], buffer, idx++, maxlen);
+	}
+
+	// append pad spaces up to given width
+	if (flags & FLAGS_LEFT) {
+		while (idx - start_idx < width) {
+			out(' ', buffer, idx++, maxlen);
+		}
+	}
+
+	return idx;
+}
+
+// internal itoa format
+static size_t _ntoa_format(
+	out_fct_type out, char *buffer, size_t idx, size_t maxlen, char *buf,
+	size_t len, bool negative, unsigned int base, unsigned int prec,
+	unsigned int width, unsigned int flags)
+{
+	// pad leading zeros
+	if (!(flags & FLAGS_LEFT)) {
+		if (width && (flags & FLAGS_ZEROPAD)
+		    && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
+			width--;
+		}
+		while ((len < prec) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+			buf[len++] = '0';
+		}
+		while ((flags & FLAGS_ZEROPAD) && (len < width)
+		       && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+			buf[len++] = '0';
+		}
+	}
+
+	// handle hash
+	if (flags & FLAGS_HASH) {
+		if (!(flags & FLAGS_PRECISION) && len
+		    && ((len == prec) || (len == width))) {
+			len--;
+			if (len && (base == 16U)) {
+				len--;
+			}
+		}
+		if ((base == 16U) && !(flags & FLAGS_UPPERCASE)
+		    && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+			buf[len++] = 'x';
+		} else if (
+			(base == 16U) && (flags & FLAGS_UPPERCASE)
+			&& (len < PRINTF_NTOA_BUFFER_SIZE)) {
+			buf[len++] = 'X';
+		} else if ((base == 2U) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+			buf[len++] = 'b';
+		}
+		if (len < PRINTF_NTOA_BUFFER_SIZE) {
+			buf[len++] = '0';
+		}
+	}
+
+	if (len < PRINTF_NTOA_BUFFER_SIZE) {
+		if (negative) {
+			buf[len++] = '-';
+		} else if (flags & FLAGS_PLUS) {
+			buf[len++] = '+';   // ignore the space if the '+' exists
+		} else if (flags & FLAGS_SPACE) {
+			buf[len++] = ' ';
+		}
+	}
+
+	return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
+}
+
+// internal itoa for 'long' type
+static size_t _ntoa_long(
+	out_fct_type out, char *buffer, size_t idx, size_t maxlen,
+	unsigned long value, bool negative, unsigned long base,
+	unsigned int prec, unsigned int width, unsigned int flags)
+{
+	char buf[PRINTF_NTOA_BUFFER_SIZE];
+	size_t len = 0U;
+
+	// no hash for 0 values
+	if (!value) {
+		flags &= ~FLAGS_HASH;
+	}
+
+	// write if precision != 0 and value is != 0
+	if (!(flags & FLAGS_PRECISION) || value) {
+		do {
+			const char digit = (char)(value % base);
+			buf[len++] = digit < 10
+			                   ? '0' + digit
+			                   : (flags & FLAGS_UPPERCASE ? 'A' : 'a')
+			                             + digit - 10;
+			value /= base;
+		} while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
+	}
+
+	return _ntoa_format(
+		out, buffer, idx, maxlen, buf, len, negative,
+		(unsigned int)base, prec, width, flags);
+}
+
+// internal itoa for 'long long' type
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+static size_t _ntoa_long_long(
+	out_fct_type out, char *buffer, size_t idx, size_t maxlen,
+	unsigned long long value, bool negative, unsigned long long base,
+	unsigned int prec, unsigned int width, unsigned int flags)
+{
+	char buf[PRINTF_NTOA_BUFFER_SIZE];
+	size_t len = 0U;
+
+	// no hash for 0 values
+	if (!value) {
+		flags &= ~FLAGS_HASH;
+	}
+
+	// write if precision != 0 and value is != 0
+	if (!(flags & FLAGS_PRECISION) || value) {
+		do {
+			const char digit = (char)(value % base);
+			buf[len++] = digit < 10
+			                   ? '0' + digit
+			                   : (flags & FLAGS_UPPERCASE ? 'A' : 'a')
+			                             + digit - 10;
+			value /= base;
+		} while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
+	}
+
+	return _ntoa_format(
+		out, buffer, idx, maxlen, buf, len, negative,
+		(unsigned int)base, prec, width, flags);
+}
+#endif   // PRINTF_SUPPORT_LONG_LONG
+
+#if defined(PRINTF_SUPPORT_FLOAT)
+
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+// forward declaration so that _ftoa can switch to exp notation for values > PRINTF_MAX_FLOAT
+static size_t _etoa(
+	out_fct_type out, char *buffer, size_t idx, size_t maxlen, double value,
+	unsigned int prec, unsigned int width, unsigned int flags);
+#endif
+
+// internal ftoa for fixed decimal floating point
+static size_t _ftoa(
+	out_fct_type out, char *buffer, size_t idx, size_t maxlen, double value,
+	unsigned int prec, unsigned int width, unsigned int flags)
+{
+	char buf[PRINTF_FTOA_BUFFER_SIZE];
+	size_t len = 0U;
+	double diff = 0.0;
+
+	// powers of 10
+	static const double pow10[]
+		= {1,      10,      100,      1000,      10000,
+	           100000, 1000000, 10000000, 100000000, 1000000000};
+
+	// test for special values
+	if (value != value)
+		return _out_rev(out, buffer, idx, maxlen, "nan", 3, width, flags);
+	if (value < -DBL_MAX)
+		return _out_rev(out, buffer, idx, maxlen, "fni-", 4, width, flags);
+	if (value > DBL_MAX)
+		return _out_rev(
+			out, buffer, idx, maxlen,
+			(flags & FLAGS_PLUS) ? "fni+" : "fni",
+			(flags & FLAGS_PLUS) ? 4U : 3U, width, flags);
+
+	// test for very large values
+	// standard printf behavior is to print EVERY whole number digit --
+	// which could be 100s of characters overflowing your buffers == bad
+	if ((value > PRINTF_MAX_FLOAT) || (value < -PRINTF_MAX_FLOAT)) {
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+		return _etoa(out, buffer, idx, maxlen, value, prec, width, flags);
+#else
+		return 0U;
+#endif
+	}
+
+	// test for negative
+	bool negative = false;
+	if (value < 0) {
+		negative = true;
+		value = 0 - value;
+	}
+
+	// set default precision, if not set explicitly
+	if (!(flags & FLAGS_PRECISION)) {
+		prec = PRINTF_DEFAULT_FLOAT_PRECISION;
+	}
+	// limit precision to 9, cause a prec >= 10 can lead to overflow errors
+	while ((len < PRINTF_FTOA_BUFFER_SIZE) && (prec > 9U)) {
+		buf[len++] = '0';
+		prec--;
+	}
+
+	int whole = (int)value;
+	double tmp = (value - whole) * pow10[prec];
+	unsigned long frac = (unsigned long)tmp;
+	diff = tmp - frac;
+
+	if (diff > 0.5) {
+		++frac;
+		// handle rollover, e.g. case 0.99 with prec 1 is 1.0
+		if (frac >= pow10[prec]) {
+			frac = 0;
+			++whole;
+		}
+	} else if (diff < 0.5) {
+	} else if ((frac == 0U) || (frac & 1U)) {
+		// if halfway, round up if odd OR if last digit is 0
+		++frac;
+	}
+
+	if (prec == 0U) {
+		diff = value - (double)whole;
+		if ((!(diff < 0.5) || (diff > 0.5)) && (whole & 1)) {
+			// exactly 0.5 and ODD, then round up
+			// 1.5 -> 2, but 2.5 -> 2
+			++whole;
+		}
+	} else {
+		unsigned int count = prec;
+		// now do fractional part, as an unsigned number
+		while (len < PRINTF_FTOA_BUFFER_SIZE) {
+			--count;
+			buf[len++] = (char)(48U + (frac % 10U));
+			if (!(frac /= 10U)) {
+				break;
+			}
+		}
+		// add extra 0s
+		while ((len < PRINTF_FTOA_BUFFER_SIZE) && (count-- > 0U)) {
+			buf[len++] = '0';
+		}
+		if (len < PRINTF_FTOA_BUFFER_SIZE) {
+			// add decimal
+			buf[len++] = '.';
+		}
+	}
+
+	// do whole part, number is reversed
+	while (len < PRINTF_FTOA_BUFFER_SIZE) {
+		buf[len++] = (char)(48 + (whole % 10));
+		if (!(whole /= 10)) {
+			break;
+		}
+	}
+
+	// pad leading zeros
+	if (!(flags & FLAGS_LEFT) && (flags & FLAGS_ZEROPAD)) {
+		if (width && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
+			width--;
+		}
+		while ((len < width) && (len < PRINTF_FTOA_BUFFER_SIZE)) {
+			buf[len++] = '0';
+		}
+	}
+
+	if (len < PRINTF_FTOA_BUFFER_SIZE) {
+		if (negative) {
+			buf[len++] = '-';
+		} else if (flags & FLAGS_PLUS) {
+			buf[len++] = '+';   // ignore the space if the '+' exists
+		} else if (flags & FLAGS_SPACE) {
+			buf[len++] = ' ';
+		}
+	}
+
+	return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
+}
+
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+// internal ftoa variant for exponential floating-point type, contributed by Martijn Jasperse <m.jasperse@gmail.com>
+static size_t _etoa(
+	out_fct_type out, char *buffer, size_t idx, size_t maxlen, double value,
+	unsigned int prec, unsigned int width, unsigned int flags)
+{
+	// check for NaN and special values
+	if ((value != value) || (value > DBL_MAX) || (value < -DBL_MAX)) {
+		return _ftoa(out, buffer, idx, maxlen, value, prec, width, flags);
+	}
+
+	// determine the sign
+	const bool negative = value < 0;
+	if (negative) {
+		value = -value;
+	}
+
+	// default precision
+	if (!(flags & FLAGS_PRECISION)) {
+		prec = PRINTF_DEFAULT_FLOAT_PRECISION;
+	}
+
+	// determine the decimal exponent
+	// based on the algorithm by David Gay (https://www.ampl.com/netlib/fp/dtoa.c)
+	union {
+		uint64_t U;
+		double F;
+	} conv;
+
+	conv.F = value;
+	int exp2 = (int)((conv.U >> 52U) & 0x07FFU) - 1023;   // effectively log2
+	conv.U = (conv.U & ((1ULL << 52U) - 1U))
+	       | (1023ULL << 52U);   // drop the exponent so conv.F is now in [1,2)
+	// now approximate log10 from the log2 integer part and an expansion of ln around 1.5
+	int expval = (int)(0.1760912590558 + exp2 * 0.301029995663981
+	                   + (conv.F - 1.5) * 0.289529654602168);
+	// now we want to compute 10^expval but we want to be sure it won't overflow
+	exp2 = (int)(expval * 3.321928094887362 + 0.5);
+	const double z = expval * 2.302585092994046 - exp2 * 0.6931471805599453;
+	const double z2 = z * z;
+	conv.U = (uint64_t)(exp2 + 1023) << 52U;
+	// compute exp(z) using continued fractions, see https://en.wikipedia.org/wiki/Exponential_function#Continued_fractions_for_ex
+	conv.F *= 1 + 2 * z / (2 - z + (z2 / (6 + (z2 / (10 + z2 / 14)))));
+	// correct for rounding errors
+	if (value < conv.F) {
+		expval--;
+		conv.F /= 10;
+	}
+
+	// the exponent format is "%+03d" and largest value is "307", so set aside 4-5 characters
+	unsigned int minwidth = ((expval < 100) && (expval > -100)) ? 4U : 5U;
+
+	// in "%g" mode, "prec" is the number of *significant figures* not decimals
+	if (flags & FLAGS_ADAPT_EXP) {
+		// do we want to fall-back to "%f" mode?
+		if ((value >= 1e-4) && (value < 1e6)) {
+			if ((int)prec > expval) {
+				prec = (unsigned)((int)prec - expval - 1);
+			} else {
+				prec = 0;
+			}
+			flags |= FLAGS_PRECISION;   // make sure _ftoa respects precision
+			// no characters in exponent
+			minwidth = 0U;
+			expval = 0;
+		} else {
+			// we use one sigfig for the whole part
+			if ((prec > 0) && (flags & FLAGS_PRECISION)) {
+				--prec;
+			}
+		}
+	}
+
+	// will everything fit?
+	unsigned int fwidth = width;
+	if (width > minwidth) {
+		// we didn't fall-back so subtract the characters required for the exponent
+		fwidth -= minwidth;
+	} else {
+		// not enough characters, so go back to default sizing
+		fwidth = 0U;
+	}
+	if ((flags & FLAGS_LEFT) && minwidth) {
+		// if we're padding on the right, DON'T pad the floating part
+		fwidth = 0U;
+	}
+
+	// rescale the float value
+	if (expval) {
+		value /= conv.F;
+	}
+
+	// output the floating part
+	const size_t start_idx = idx;
+	idx
+		= _ftoa(out, buffer, idx, maxlen, negative ? -value : value,
+	                prec, fwidth, flags & ~FLAGS_ADAPT_EXP);
+
+	// output the exponent part
+	if (minwidth) {
+		// output the exponential symbol
+		out((flags & FLAGS_UPPERCASE) ? 'E' : 'e', buffer, idx++, maxlen);
+		// output the exponent value
+		idx = _ntoa_long(
+			out, buffer, idx, maxlen,
+			(expval < 0) ? -expval : expval, expval < 0, 10, 0,
+			minwidth - 1, FLAGS_ZEROPAD | FLAGS_PLUS);
+		// might need to right-pad spaces
+		if (flags & FLAGS_LEFT) {
+			while (idx - start_idx < width)
+				out(' ', buffer, idx++, maxlen);
+		}
+	}
+	return idx;
+}
+#endif   // PRINTF_SUPPORT_EXPONENTIAL
+#endif   // PRINTF_SUPPORT_FLOAT
+
+// internal vsnprintf
+static int _vsnprintf(
+	out_fct_type out, char *buffer, const size_t maxlen, const char *format,
+	va_list va)
+{
+	unsigned int flags, width, precision, n;
+	size_t idx = 0U;
+
+	if (!buffer) {
+		// use null output function
+		out = _out_null;
+	}
+
+	while (*format) {
+		// format specifier?  %[flags][width][.precision][length]
+		if (*format != '%') {
+			// no
+			out(*format, buffer, idx++, maxlen);
+			format++;
+			continue;
+		} else {
+			// yes, evaluate it
+			format++;
+		}
+
+		// evaluate flags
+		flags = 0U;
+		do {
+			switch (*format) {
+			case '0':
+				flags |= FLAGS_ZEROPAD;
+				format++;
+				n = 1U;
+				break;
+			case '-':
+				flags |= FLAGS_LEFT;
+				format++;
+				n = 1U;
+				break;
+			case '+':
+				flags |= FLAGS_PLUS;
+				format++;
+				n = 1U;
+				break;
+			case ' ':
+				flags |= FLAGS_SPACE;
+				format++;
+				n = 1U;
+				break;
+			case '#':
+				flags |= FLAGS_HASH;
+				format++;
+				n = 1U;
+				break;
+			default:
+				n = 0U;
+				break;
+			}
+		} while (n);
+
+		// evaluate width field
+		width = 0U;
+		if (_is_digit(*format)) {
+			width = _atoi(&format);
+		} else if (*format == '*') {
+			const int w = va_arg(va, int);
+			if (w < 0) {
+				flags |= FLAGS_LEFT;   // reverse padding
+				width = (unsigned int)-w;
+			} else {
+				width = (unsigned int)w;
+			}
+			format++;
+		}
+
+		// evaluate precision field
+		precision = 0U;
+		if (*format == '.') {
+			flags |= FLAGS_PRECISION;
+			format++;
+			if (_is_digit(*format)) {
+				precision = _atoi(&format);
+			} else if (*format == '*') {
+				const int prec = (int)va_arg(va, int);
+				precision = prec > 0 ? (unsigned int)prec : 0U;
+				format++;
+			}
+		}
+
+		// evaluate length field
+		switch (*format) {
+		case 'l':
+			flags |= FLAGS_LONG;
+			format++;
+			if (*format == 'l') {
+				flags |= FLAGS_LONG_LONG;
+				format++;
+			}
+			break;
+		case 'h':
+			flags |= FLAGS_SHORT;
+			format++;
+			if (*format == 'h') {
+				flags |= FLAGS_CHAR;
+				format++;
+			}
+			break;
+#if defined(PRINTF_SUPPORT_PTRDIFF_T)
+		case 't':
+			flags
+				|= (sizeof(ptrdiff_t) == sizeof(long)
+			                    ? FLAGS_LONG
+			                    : FLAGS_LONG_LONG);
+			format++;
+			break;
+#endif
+		case 'j':
+			flags
+				|= (sizeof(intmax_t) == sizeof(long)
+			                    ? FLAGS_LONG
+			                    : FLAGS_LONG_LONG);
+			format++;
+			break;
+		case 'z':
+			flags
+				|= (sizeof(size_t) == sizeof(long)
+			                    ? FLAGS_LONG
+			                    : FLAGS_LONG_LONG);
+			format++;
+			break;
+		default:
+			break;
+		}
+
+		// evaluate specifier
+		switch (*format) {
+		case 'd':
+		case 'i':
+		case 'u':
+		case 'x':
+		case 'X':
+		case 'o':
+		case 'b': {
+			// set the base
+			unsigned int base;
+			if (*format == 'x' || *format == 'X') {
+				base = 16U;
+			} else if (*format == 'o') {
+				base = 8U;
+			} else if (*format == 'b') {
+				base = 2U;
+			} else {
+				base = 10U;
+				flags &= ~FLAGS_HASH;   // no hash for dec format
+			}
+			// uppercase
+			if (*format == 'X') {
+				flags |= FLAGS_UPPERCASE;
+			}
+
+			// no plus or space flag for u, x, X, o, b
+			if ((*format != 'i') && (*format != 'd')) {
+				flags &= ~(FLAGS_PLUS | FLAGS_SPACE);
+			}
+
+			// ignore '0' flag when precision is given
+			if (flags & FLAGS_PRECISION) {
+				flags &= ~FLAGS_ZEROPAD;
+			}
+
+			// convert the integer
+			if ((*format == 'i') || (*format == 'd')) {
+				// signed
+				if (flags & FLAGS_LONG_LONG) {
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+					const long long value
+						= va_arg(va, long long);
+					idx = _ntoa_long_long(
+						out, buffer, idx, maxlen,
+						(unsigned long long)(value > 0 ? value
+					                                       : 0 - value),
+						value < 0, base, precision,
+						width, flags);
+#endif
+				} else if (flags & FLAGS_LONG) {
+					const long value = va_arg(va, long);
+					idx = _ntoa_long(
+						out, buffer, idx, maxlen,
+						(unsigned long)(value > 0 ? value
+					                                  : 0 - value),
+						value < 0, base, precision,
+						width, flags);
+				} else {
+					const int value
+						= (flags & FLAGS_CHAR)
+					                ? (char)va_arg(va, int)
+					        : (flags & FLAGS_SHORT)
+					                ? (short int)va_arg(va, int)
+					                : va_arg(va, int);
+					idx = _ntoa_long(
+						out, buffer, idx, maxlen,
+						(unsigned int)(value > 0 ? value
+					                                 : 0 - value),
+						value < 0, base, precision,
+						width, flags);
+				}
+			} else {
+				// unsigned
+				if (flags & FLAGS_LONG_LONG) {
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+					idx = _ntoa_long_long(
+						out, buffer, idx, maxlen,
+						va_arg(va, unsigned long long),
+						false, base, precision, width,
+						flags);
+#endif
+				} else if (flags & FLAGS_LONG) {
+					idx = _ntoa_long(
+						out, buffer, idx, maxlen,
+						va_arg(va, unsigned long), false,
+						base, precision, width, flags);
+				} else {
+					const unsigned int value
+						= (flags & FLAGS_CHAR)
+					                ? (unsigned char)va_arg(
+								  va, unsigned int)
+					        : (flags & FLAGS_SHORT)
+					                ? (unsigned short int)va_arg(
+								  va, unsigned int)
+					                : va_arg(va, unsigned int);
+					idx = _ntoa_long(
+						out, buffer, idx, maxlen, value,
+						false, base, precision, width,
+						flags);
+				}
+			}
+			format++;
+			break;
+		}
+#if defined(PRINTF_SUPPORT_FLOAT)
+		case 'f':
+		case 'F':
+			if (*format == 'F')
+				flags |= FLAGS_UPPERCASE;
+			idx = _ftoa(
+				out, buffer, idx, maxlen, va_arg(va, double),
+				precision, width, flags);
+			format++;
+			break;
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+		case 'e':
+		case 'E':
+		case 'g':
+		case 'G':
+			if ((*format == 'g') || (*format == 'G'))
+				flags |= FLAGS_ADAPT_EXP;
+			if ((*format == 'E') || (*format == 'G'))
+				flags |= FLAGS_UPPERCASE;
+			idx = _etoa(
+				out, buffer, idx, maxlen, va_arg(va, double),
+				precision, width, flags);
+			format++;
+			break;
+#endif   // PRINTF_SUPPORT_EXPONENTIAL
+#endif   // PRINTF_SUPPORT_FLOAT
+		case 'c': {
+			unsigned int l = 1U;
+			// pre padding
+			if (!(flags & FLAGS_LEFT)) {
+				while (l++ < width) {
+					out(' ', buffer, idx++, maxlen);
+				}
+			}
+			// char output
+			out((char)va_arg(va, int), buffer, idx++, maxlen);
+			// post padding
+			if (flags & FLAGS_LEFT) {
+				while (l++ < width) {
+					out(' ', buffer, idx++, maxlen);
+				}
+			}
+			format++;
+			break;
+		}
+
+		case 's': {
+			const char *p = va_arg(va, char *);
+			unsigned int l = _strnlen_s(
+				p, precision ? precision : (size_t)-1);
+			// pre padding
+			if (flags & FLAGS_PRECISION) {
+				l = (l < precision ? l : precision);
+			}
+			if (!(flags & FLAGS_LEFT)) {
+				while (l++ < width) {
+					out(' ', buffer, idx++, maxlen);
+				}
+			}
+			// string output
+			while ((*p != 0)
+			       && (!(flags & FLAGS_PRECISION) || precision--)) {
+				out(*(p++), buffer, idx++, maxlen);
+			}
+			// post padding
+			if (flags & FLAGS_LEFT) {
+				while (l++ < width) {
+					out(' ', buffer, idx++, maxlen);
+				}
+			}
+			format++;
+			break;
+		}
+
+		case 'p': {
+			width = sizeof(void *) * 2U;
+			flags |= FLAGS_ZEROPAD | FLAGS_UPPERCASE;
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+			const bool is_ll = sizeof(uintptr_t) == sizeof(long long);
+			if (is_ll) {
+				idx = _ntoa_long_long(
+					out, buffer, idx, maxlen,
+					(uintptr_t)va_arg(va, void *), false,
+					16U, precision, width, flags);
+			} else {
+#endif
+				idx = _ntoa_long(
+					out, buffer, idx, maxlen,
+					(unsigned long)((uintptr_t)va_arg(
+						va, void *)),
+					false, 16U, precision, width, flags);
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+			}
+#endif
+			format++;
+			break;
+		}
+
+		case '%':
+			out('%', buffer, idx++, maxlen);
+			format++;
+			break;
+
+		default:
+			out(*format, buffer, idx++, maxlen);
+			format++;
+			break;
+		}
+	}
+
+	// termination
+	out((char)0, buffer, idx < maxlen ? idx : maxlen - 1U, maxlen);
+
+	// return written chars without terminating \0
+	return (int)idx;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int z__b_fctprintf(
+	void (*out)(char character, void *arg), void *arg, const char *format,
+	va_list va)
+{
+	const out_fct_wrap_type out_fct_wrap = {out, arg};
+	const int ret = _vsnprintf(
+		_out_fct, (char *)(uintptr_t)&out_fct_wrap, (size_t)-1, format, va);
+	return ret;
+}
diff --git a/core/printf.h b/core/printf.h
new file mode 100644
index 0000000..0c1f31a
--- /dev/null
+++ b/core/printf.h
@@ -0,0 +1,59 @@
+///////////////////////////////////////////////////////////////////////////////
+// \author (c) Marco Paland (info@paland.com)
+//             2014-2019, PALANDesign Hannover, Germany
+//
+// \license The MIT License (MIT)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// \brief Tiny printf, sprintf and snprintf implementation, optimized for speed on
+//        embedded systems with a very limited resources.
+//        Use this instead of bloated standard/newlib printf.
+//        These routines are thread safe and reentrant.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _PRINTF_H_
+#define _PRINTF_H_
+
+#include <stdarg.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * printf with output function
+ * You may use this as dynamic alternative to printf() with its fixed _putchar()
+ * output \param out An output function which takes one character and an
+ * argument pointer \param arg An argument pointer for user data passed to
+ * output function \param format A string that specifies the format of the
+ * output \return The number of characters that are sent to the output function,
+ * not counting the terminating null character
+ */
+int z__b_fctprintf(
+	void (*out)(char character, void *arg), void *arg, const char *format,
+	va_list va);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif   // _PRINTF_H_
diff --git a/core/stream.c b/core/stream.c
new file mode 100644
index 0000000..ba9f610
--- /dev/null
+++ b/core/stream.c
@@ -0,0 +1,553 @@
+#include "printf.h"
+
+#include <blue/core/stream.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define IDX_STDIN  0
+#define IDX_STDOUT 1
+#define IDX_STDERR 2
+
+static b_status stdio_read(
+	struct b_stream *stream, unsigned char *out, size_t max, size_t *nr_read)
+{
+	FILE *fp = stream->s_ptr;
+	size_t count = 0;
+	enum b_status status = B_SUCCESS;
+
+	for (size_t i = 0; i < max; i++) {
+		int c = fgetc(fp);
+		if (ferror(fp)) {
+			status = B_ERR_IO_FAILURE;
+			break;
+		}
+
+		if (c == -1) {
+			break;
+		}
+
+		out[count++] = c;
+	}
+
+	*nr_read = count;
+	return status;
+}
+
+static b_status stdio_write(
+	struct b_stream *stream, const unsigned char *data, size_t count,
+	size_t *nr_written)
+{
+	FILE *fp = stream->s_ptr;
+	enum b_status status = B_SUCCESS;
+	size_t w = 0;
+
+	for (size_t i = 0; i < count; i++) {
+		fputc(data[i], fp);
+
+		if (ferror(fp)) {
+			status = B_ERR_IO_FAILURE;
+			break;
+		}
+
+		w++;
+	}
+
+	*nr_written = w;
+	return status;
+}
+
+static struct b_stream stdio[] = {
+	[IDX_STDIN] = {
+		.s_mode = B_STREAM_READ,
+		.s_read = stdio_read,
+		.s_ptr = NULL, /* set to stdin (stdio.h) at runtime */
+	},
+	[IDX_STDOUT] = {
+		.s_mode = B_STREAM_WRITE,
+		.s_write = stdio_write,
+		.s_ptr = NULL, /* set to stdout (stdio.h) at runtime */
+	},
+	[IDX_STDERR] = {
+		.s_mode = B_STREAM_WRITE,
+		.s_write = stdio_write,
+		.s_ptr = NULL, /* set to stderr (stdio.h) at runtime */
+	},
+};
+
+struct b_stream *z__b_stream_get_stdin(void)
+{
+	stdio[IDX_STDIN].s_ptr = stdin;
+	return &stdio[IDX_STDIN];
+}
+
+struct b_stream *z__b_stream_get_stdout(void)
+{
+	stdio[IDX_STDOUT].s_ptr = stdout;
+	return &stdio[IDX_STDOUT];
+}
+
+struct b_stream *z__b_stream_get_stderr(void)
+{
+	stdio[IDX_STDERR].s_ptr = stderr;
+	return &stdio[IDX_STDERR];
+}
+
+enum b_status b_stream_pipeline_create(
+	size_t buffer_size, struct b_stream_pipeline **out)
+{
+	struct b_stream_pipeline *pipeline = malloc(sizeof *pipeline);
+	if (!pipeline) {
+		return B_ERR_NO_MEMORY;
+	}
+
+	memset(pipeline, 0x0, sizeof *pipeline);
+
+	pipeline->p_buf = malloc(buffer_size);
+	if (!pipeline->p_buf) {
+		free(pipeline);
+		return B_ERR_NO_MEMORY;
+	}
+
+	pipeline->p_buf_len = buffer_size;
+	pipeline->p_flags
+		= B_STREAM_PIPELINE_F_DYNAMIC | B_STREAM_PIPELINE_F_BUF_DYNAMIC;
+
+	*out = pipeline;
+	return B_SUCCESS;
+}
+
+enum b_status b_stream_pipeline_init(
+	void *p, size_t len, struct b_stream_pipeline *out)
+{
+	memset(out, 0x0, sizeof *out);
+
+	out->p_buf = p;
+	out->p_buf_len = len;
+
+	return B_SUCCESS;
+}
+
+enum b_status b_stream_pipeline_destroy(struct b_stream_pipeline *pipeline)
+{
+	if (pipeline->p_flags & B_STREAM_PIPELINE_F_BUF_DYNAMIC) {
+		free(pipeline->p_buf);
+	}
+
+	if (pipeline->p_flags & B_STREAM_PIPELINE_F_DYNAMIC) {
+		free(pipeline);
+	}
+
+	return B_SUCCESS;
+}
+
+enum b_status b_stream_close(b_stream *stream)
+{
+	if (stream->s_istack) {
+		free(stream->s_istack);
+	}
+
+	if (stream->s_close) {
+		stream->s_close(stream);
+	}
+
+	if (!(stream->s_mode & Z__B_STREAM_STATIC)) {
+		free(stream);
+	}
+
+	return B_SUCCESS;
+}
+
+enum b_status b_stream_reserve(b_stream *stream, size_t len)
+{
+	if (!stream->s_reserve) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	return stream->s_reserve(stream, len);
+}
+
+enum b_status b_stream_seek(
+	b_stream *stream, long long offset, b_stream_seek_origin origin)
+{
+	if (!stream->s_seek) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	return stream->s_seek(stream, offset, origin);
+}
+
+size_t b_stream_cursor(const b_stream *stream)
+{
+	return stream->s_cursor;
+}
+
+enum b_status b_stream_push_indent(b_stream *stream, int indent)
+{
+	if (!(stream->s_mode & B_STREAM_WRITE)) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	if (stream->s_mode & B_STREAM_BINARY) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	if (!stream->s_istack) {
+		stream->s_istack = calloc(4, sizeof(int));
+		stream->s_istack_size = 4;
+		stream->s_istack_ptr = 0;
+	}
+
+	if (stream->s_istack_ptr + 1 > stream->s_istack_size) {
+		int *buf = realloc(
+			stream->s_istack,
+			(stream->s_istack_size + 4) * sizeof(int));
+		if (!buf) {
+			return B_ERR_NO_MEMORY;
+		}
+
+		stream->s_istack = buf;
+		stream->s_istack_size += 4;
+	}
+
+	int cur_indent = stream->s_istack[stream->s_istack_ptr];
+	stream->s_istack[++stream->s_istack_ptr] = cur_indent + indent;
+
+	return B_SUCCESS;
+}
+
+enum b_status b_stream_pop_indent(b_stream *stream)
+{
+	if (!(stream->s_mode & B_STREAM_WRITE)) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	if (stream->s_mode & B_STREAM_BINARY) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	if (!stream->s_istack || !stream->s_istack_size || !stream->s_istack_ptr) {
+		return B_SUCCESS;
+	}
+
+	stream->s_istack_ptr--;
+	return B_SUCCESS;
+}
+
+enum b_status b_stream_read_char(struct b_stream *stream, int *c)
+{
+	if (!(stream->s_mode & B_STREAM_READ)) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	enum b_status status = B_ERR_NOT_SUPPORTED;
+
+	if (stream->s_getc) {
+		status = stream->s_getc(stream, c);
+	} else if (stream->s_read) {
+		size_t r;
+		unsigned char v = 0;
+		status = stream->s_read(stream, &v, 1, &r);
+
+		*c = v;
+
+		if (status == B_SUCCESS && r < 1) {
+			status = B_ERR_NO_DATA;
+		}
+	}
+
+	return status;
+}
+
+enum b_status b_stream_read_bytes(
+	struct b_stream *stream, void *buf, size_t count, size_t *nr_read)
+{
+	if (!(stream->s_mode & B_STREAM_READ)) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	enum b_status status = B_ERR_NOT_SUPPORTED;
+
+	if (!stream->s_read) {
+		return status;
+	}
+
+	return stream->s_read(stream, buf, count, nr_read);
+}
+
+enum b_status b_stream_read_line(struct b_stream *stream, char *s, size_t max)
+{
+	if (!(stream->s_mode & B_STREAM_READ)) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	enum b_status status = B_SUCCESS;
+
+	size_t i = 0;
+	int c = 0;
+
+	while (1) {
+		if (i >= max) {
+			break;
+		}
+
+		status = b_stream_read_char(stream, &c);
+		if (status != B_SUCCESS) {
+			break;
+		}
+
+		if (c == '\n') {
+			break;
+		}
+
+		s[i++] = c;
+		s[i] = '\0';
+	}
+
+	return B_SUCCESS;
+}
+
+enum b_status b_stream_read_line_s(struct b_stream *src, b_stream *dest)
+{
+	if (!(src->s_mode & B_STREAM_READ)) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	if (!(dest->s_mode & B_STREAM_WRITE)) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	enum b_status status = B_SUCCESS;
+
+	size_t i = 0;
+	int c = 0;
+
+	while (1) {
+		status = b_stream_read_char(src, &c);
+		if (status != B_SUCCESS) {
+			break;
+		}
+
+		if (c == '\n') {
+			break;
+		}
+
+		b_stream_write_char(dest, c);
+	}
+
+	return B_SUCCESS;
+}
+
+enum b_status b_stream_read_all_bytes(
+	struct b_stream *stream, void *p, size_t max, size_t *out_nr_read)
+{
+	if (!(stream->s_mode & B_STREAM_READ)) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	enum b_status status = B_SUCCESS;
+	size_t nr_read = 0;
+	unsigned char *s = p;
+
+	while (nr_read < max) {
+		int c;
+		status = b_stream_read_char(stream, &c);
+		if (status != B_SUCCESS) {
+			break;
+		}
+
+		s[nr_read++] = c;
+	}
+
+	if (status == B_ERR_NO_DATA && nr_read > 0) {
+		status = B_SUCCESS;
+	}
+
+	*out_nr_read = nr_read;
+	return status;
+}
+
+enum b_status b_stream_read_all_bytes_s(
+	struct b_stream *src, struct b_stream *dest,
+	struct b_stream_pipeline *pipeline, size_t *out_nr_read)
+{
+	if (!(src->s_mode & B_STREAM_READ)) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	if (!(dest->s_mode & B_STREAM_WRITE)) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	if (!pipeline) {
+		return B_ERR_INVALID_ARGUMENT;
+	}
+
+	if (src->s_seek && dest->s_reserve) {
+		size_t offset = b_stream_cursor(src);
+		b_stream_seek(src, 0, B_STREAM_SEEK_END);
+		size_t length = b_stream_cursor(src);
+		b_stream_seek(src, offset, B_STREAM_SEEK_START);
+
+		b_stream_reserve(dest, length);
+	}
+
+	enum b_status status = B_SUCCESS;
+	size_t nr_read = 0;
+
+	while (1) {
+		size_t r = 0, w = 0;
+		status = b_stream_read_bytes(
+			src, pipeline->p_buf, pipeline->p_buf_len, &r);
+		if (status != B_SUCCESS) {
+			break;
+		}
+
+		status = b_stream_write_bytes(dest, pipeline->p_buf, r, &w);
+		nr_read += w;
+
+		if (status != B_SUCCESS || w != pipeline->p_buf_len) {
+			break;
+		}
+	}
+
+	if (status == B_ERR_NO_DATA && nr_read > 0) {
+		status = B_SUCCESS;
+	}
+
+	if (out_nr_read) {
+		*out_nr_read = nr_read;
+	}
+
+	return status;
+}
+
+static enum b_status __write_char(struct b_stream *stream, char c)
+{
+	size_t w;
+	enum b_status status = stream->s_write(stream, (unsigned char *)&c, 1, &w);
+
+	if (status == B_SUCCESS && w < 1) {
+		status = B_ERR_IO_FAILURE;
+	}
+
+	return status;
+}
+
+static int current_indent(struct b_stream *stream)
+{
+	if (!stream->s_istack || !stream->s_istack_size) {
+		return 0;
+	}
+
+	return stream->s_istack[stream->s_istack_ptr];
+}
+
+enum b_status b_stream_write_char(struct b_stream *stream, char c)
+{
+	if (!(stream->s_mode & B_STREAM_WRITE)) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	enum b_status status = B_ERR_NOT_SUPPORTED;
+
+	if (!stream->s_write) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	if (c == '\n') {
+		stream->s_add_indent = 1;
+	}
+
+	if (!stream->s_istack_size) {
+		return __write_char(stream, c);
+	}
+
+	if (stream->s_add_indent && c != '\n') {
+		int indent = current_indent(stream);
+		for (int i = 0; i < indent; i++) {
+			__write_char(stream, ' ');
+			__write_char(stream, ' ');
+		}
+
+		stream->s_add_indent = 0;
+	}
+
+	__write_char(stream, c);
+
+	if (c == '\n') {
+		stream->s_add_indent = 1;
+	}
+
+	return B_SUCCESS;
+}
+
+enum b_status b_stream_write_string(
+	b_stream *stream, const char *s, size_t *nr_written)
+{
+	size_t i;
+	enum b_status status = B_SUCCESS;
+
+	for (i = 0; s[i]; i++) {
+		status = b_stream_write_char(stream, s[i]);
+
+		if (!B_OK(status)) {
+			break;
+		}
+	}
+
+	if (nr_written) {
+		*nr_written = i;
+	}
+
+	return status;
+}
+
+enum b_status b_stream_write_bytes(
+	struct b_stream *stream, void *buf, size_t count, size_t *nr_written)
+{
+	if (!(stream->s_mode & B_STREAM_WRITE)) {
+		return B_ERR_NOT_SUPPORTED;
+	}
+
+	enum b_status status = B_ERR_NOT_SUPPORTED;
+
+	if (!stream->s_write) {
+		return status;
+	}
+
+	return stream->s_write(stream, buf, count, nr_written);
+}
+
+static void fctprintf_callback(char c, void *p)
+{
+	struct b_stream *stream = p;
+	b_stream_write_char(stream, c);
+}
+
+enum b_status b_stream_write_fmt(
+	b_stream *stream, size_t *nr_written, const char *format, ...)
+{
+	va_list arg;
+	va_start(arg, format);
+	int w = z__b_fctprintf(fctprintf_callback, stream, format, arg);
+	va_end(arg);
+
+	if (nr_written) {
+		*nr_written = w;
+	}
+
+	return B_SUCCESS;
+}
+
+enum b_status b_stream_write_vfmt(
+	b_stream *stream, size_t *nr_written, const char *format, va_list arg)
+{
+	int w = z__b_fctprintf(fctprintf_callback, stream, format, arg);
+
+	if (nr_written) {
+		*nr_written = w;
+	}
+
+	return B_SUCCESS;
+}