Need help with tbox?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

Global Rank
Topics of expertise
Shanghai, China
3.8K Stars 591 Forks Apache License 2.0 3.0K Commits 14 Opened issues


🎁 A glib-like multi-platform c library

Services available

Free trial

Need anything else?

Contributors list

A glib-like cross-platform C library

Supporting the project

Support this project by becoming a sponsor. Your logo will show up here with a link to your website. 🙏 [Become a sponsor]

Introduction (中文)

TBOX is a glib-like cross-platform C library that is simple to use yet powerful in nature.

The project focuses on making C development easier and provides many modules (.e.g stream, coroutine, regex, container, algorithm ...), so that any developer can quickly pick it up and enjoy the productivity boost when developing in C language.

It supports the following platforms: Windows, Macosx, Linux, Android, iOS, *BSD and etc.

And it provides many compiling options using xmake:

  • Release: Disable debug information, assertion, memory checking and enable optimization.
  • Debug: Enable debug information, assertion, memory checking and disable optimization.
  • Small: Disable all extensional modules and enable space optimization.
  • Micro: compiling micro library (~64K) for the embed system.

If you want to know more, please refer to: Documents, Github and Gitee


The stream library

  • Supports file, data, http and socket source
  • Supports the stream filter for gzip, charset and...
  • Implements stream transfer
  • Implements the static buffer stream for parsing data
  • Supports coroutine and implements asynchronous operation

The coroutine library

  • Provides high-performance coroutine switch
  • Supports arm, arm64, x86, x86_64 ..
  • Provides channel interfaces
  • Provides semaphore and lock interfaces
  • Supports io socket and stream operation in coroutine
  • Provides some io servers (http ..) using coroutine
  • Provides stackfull and stackless coroutines
  • Support epoll, kqueue, poll, select and IOCP
  • Support to wait pipe, socket and process in coroutine and poller at same time

The database library

  • Supports mysql and sqlite3 database and enumerates data using the iterator mode

The xml parser library

  • Supports DOM and SAX mode and Supports xpath

The serialization and deserialization library

  • Supports xml, json, bplist, xplist, binary formats

The memory library

  • Implements some memory pools for optimizing memory
  • Supports fast memory error detecting. it can detect the following types of bugs for the debug mode:
    • out-of-bounds accesses to heap and globals
    • use-after-free
    • double-free, invalid free
    • memory leaks

The container library

  • Implements hash table, single list, double list, vector, stack, queue and min/max heap. Supports iterator mode for algorithm

The algorithm library

  • Uses the iterator mode
  • Implements find, binary find and reverse find algorithm
  • Implements sort, bubble sort, quick sort, heap sort and insert sort algorithm
  • Implements count, walk items, reverse walk items, forall and rforall

The network library

  • Implements dns(cached)
  • Implements ssl(openssl, polarssl, mbedtls)
  • Implements http
  • Implements cookies
  • Supports ipv4, ipv6
  • Supports coroutine

The platform library

  • Implements timer, fast and low precision timer
  • Implements atomic and atomic64 operation
  • Implements spinlock, mutex, event, semaphore, thread and thread pool
  • Implements file, socket operation
  • Implements poller using epoll, poll, select, kqueue ...
  • Implements switch context interfaces for coroutine

The charset library

  • Supports utf8, utf16, gbk, gb2312, uc2 and uc4
  • Supports big endian and little endian mode

The zip library

  • Supports gzip, zlibraw, zlib formats using the zlib library if exists
  • Implements lzsw, lz77 and rlc algorithm

The utils library

  • Implements base32, base64 encoder and decoder
  • Implements assert and trace output for the debug mode
  • Implements bits operation for parsing u8, u16, u32, u64 data

The math library

  • Implements random generator
  • Implements fast fixed-point calculation, Supports 6-bits, 16-bits, 30-bits fixed-point number

The libc library

  • Implements lightweight libc library interfaces, the interface name contains
    prefix for avoiding conflict
  • Implements strixxx strrxxx wcsixxx wcsrxxx interface extension
  • Optimizes some frequently-used interface, .e.g. memset, memcpy, strcpy ...
  • Implements
    extension interfaces

The libm library

  • Implements lightweight libm library interfaces, the interface name contains
    prefix for avoiding conflict
  • Supports float and double type

The regex library

  • Supports match and replace
  • Supports global/multiline/caseless mode
  • Uses pcre, pcre2 and posix regex modules

The hash library

  • Implements crc32, adler32, md5 and sha1 hash algorithm
  • Implements some string hash algorithms (.e.g bkdr, fnv32, fnv64, sdbm, djb2, rshash, aphash ...)
  • Implements uuid generator


Some projects using tbox:


Please install xmake first: xmake

# build for the host platform
$ cd ./tbox
$ xmake

build for the mingw platform

$ cd ./tbox $ xmake f -p mingw --sdk=/home/mingwsdk $ xmake

build for the iphoneos platform

$ cd ./tbox $ xmake f -p iphoneos $ xmake

build for the android platform

$ cd ./tbox $ xmake f -p android --ndk=xxxxx $ xmake

build for the linux cross-platform

$ cd ./tbox $ xmake f -p linux --sdk=/home/sdk # --bin=/home/sdk/bin $ xmake


#include "tbox/tbox.h"

int main(int argc, char** argv) { // init tbox if (!tb_init(tb_null, tb_null)) return 0;

// trace
tb_trace_i("hello tbox");

// init vector
tb_vector_ref_t vector = tb_vector_init(0, tb_element_str(tb_true));
if (vector)
    // insert item
    tb_vector_insert_tail(vector, "hello");
    tb_vector_insert_tail(vector, "tbox");

    // dump all items
    tb_for_all (tb_char_t const*, cstr, vector)
        // trace
        tb_trace_i("%s", cstr);

    // exit vector

// init stream
tb_stream_ref_t stream = tb_stream_init_from_url("");
if (stream)
    // open stream
    if (tb_stream_open(stream))
        // read line
        tb_long_t size = 0;
        tb_char_t line[TB_STREAM_BLOCK_MAXN];
        while ((size = tb_stream_bread_line(stream, line, sizeof(line))) >= 0)
            // trace
            tb_trace_i("line: %s", line);

    // exit stream

// wait

// exit tbox
return 0;


Technical Support

We also provide paid technical support to help users quickly solve related problems. For details, please click the image link below:

Or you can also consider sponsoring us to get technical support services, [Become a sponsor]


We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.