i've been hanging and experimenting around modern c++  and got an idea of what c++ standard library could look like. of course, t sounds like another "c++ stdlib replacement", but i think i found interesting solutions that could be interesting to ya'all.

the goal was to make a framework that expects a modern c++ code and compiles it to a very lightweight binary. for example, this code:

    import std.io;
    
    int main() {
        println("Hello, World");
        return 0;
    }

compiles to a tiny statically linked 576 byte executable. of course, it does not link either to libc or libstdc++, using a custom runtime (instead of crt), written in fasm.

another example is an echo server (executable size is 1312 bytes):

    import std.io;
    import std.net;
    import std.string;
    import std.view;
    
    int main() {
        int sfd = socket(af_inet, sock_stream, 0)
            .expect("could not create socket");
    
        setsockopt(sfd, sol_socket, so_reuseaddr, 1)
            .expect("could not set so_reuseaddr");
    
        /* host -> network byte order is done at sockaddr_in constructor */
        sockaddr_in addr = sockaddr_in(6767, 0);
    
        bind(sfd, addr)
            .expect("bind failed");
    
        listen(sfd, 1)
            .expect("listen failed");
    
        sockaddr_in peer_addr;
        int cfd = accept(sfd, peer_addr)
            .expect("accept failed");
    
        string buf = string(128);
        for (;;) {
            /* read(int, string &) overload sets string length to actual value returned by read */
            if (!read(cfd, buf) || size(buf) == 0)
                goto close;
            write(cfd, buf);
        }
    
    close:
        close(cfd);
        close(sfd);
    
        return 0;
    }
    
    i

in both of the examples you can already see particular design choices:

1. modules are first class feature. they speed up compile time and are more convenient to use than headers
2. standard library functions are global, like in C
3. Rust-like results instead of exeptions. every syscall wrapper substitutes actual syscalls and returns a struct with a union containing either value or an error (usually an unsigned integer enum)

you can read project philosophy and get more details in the [project readme](https://github.com/antsif-a/platinum/tree/main#readme) and see another examples [here](https://github.com/antsif-a/platinum/tree/main/examples).

currently this project is nothing more than an experiment and just a compilation of some interesting ideas i got lately.

proof of concept c++ runtime & standard library