Sokol (Сокол): Russian for Falcon, a smaller and more nimble bird of prey than the Eagle (Орёл, Oryol)

See what's new (26-Apr-2019: breaking change in sokol_gfx.h)

Minimalistic header-only cross-platform libs in C:

• sokol_gfx.h: 3D-API wrapper (GL + Metal + D3D11)
• sokol_app.h: app framework wrapper (entry + window + 3D-context + input)
• sokol_time.h: time measurement
• sokol_audio.h: minimal buffer-streaming audio playback
• sokol_args.h: unified cmdline/URL arg parser for web and native apps

These are (mainly) the internal parts of the Oryol C++ framework rewritten in pure C as standalone header-only libs.

WebAssembly is a 'first-class citizen', one important motivation for the Sokol headers is to provide a collection of cross-platform APIs with a minimal footprint on the web platform while still being useful.

All headers are standalone and can be used indepedendently from each other.

Sample code is in a separate repo: https://github.com/floooh/sokol-samples

asm.js/wasm live demos: https://floooh.github.io/sokol-html5/index.html

Tiny 8-bit emulators: https://floooh.github.io/tiny8bit/

Nim bindings: https://github.com/floooh/sokol-nim

Nim samples: https://github.com/floooh/sokol-nim-samples

• easier integration with other languages
• easier integration into other projects
• allows even smaller program binaries than Oryol

Sokol will be a bit less convenient to use than Oryol, but that's ok since the Sokol headers are intended to be low-level building blocks.

Eventually Oryol will just be a thin C++ layer over Sokol.

A blog post with more background info: A Tour of sokol_gfx.h

• simple, modern wrapper around GLES2/WebGL, GLES3/WebGL2, GL3.3, D3D11 and Metal
• buffers, images, shaders, pipeline-state-objects and render-passes
• does not handle window creation or 3D API context initialization
• does not provide shader dialect cross-translation

A triangle in C99 with GLFW and FlextGL:

#define GLFW_INCLUDE_NONE
#include "GLFW/glfw3.h"
#include "flextgl/flextGL.h"
#define SOKOL_IMPL
#define SOKOL_GLCORE33
#include "sokol_gfx.h"

int main() {

    /* create window and GL context via GLFW */
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    GLFWwindow* w = glfwCreateWindow(640, 480, "Sokol Triangle GLFW", 0, 0);
    glfwMakeContextCurrent(w);
    glfwSwapInterval(1);
    flextInit();

    /* setup sokol_gfx */
    sg_setup(&(sg_desc){0});

    /* a vertex buffer */
    const float vertices[] = {
        // positions            // colors
         0.0f,  0.5f, 0.5f,     1.0f, 0.0f, 0.0f, 1.0f,
         0.5f, -0.5f, 0.5f,     0.0f, 1.0f, 0.0f, 1.0f,
        -0.5f, -0.5f, 0.5f,     0.0f, 0.0f, 1.0f, 1.0f
    };
    sg_buffer vbuf = sg_make_buffer(&(sg_buffer_desc){
        .size = sizeof(vertices),
        .content = vertices,
    });

    /* a shader */
    sg_shader shd = sg_make_shader(&(sg_shader_desc){
        .vs.source =
            "#version 330\n"
            "layout(location=0) in vec4 position;\n"
            "layout(location=1) in vec4 color0;\n"
            "out vec4 color;\n"
            "void main() {\n"
            "  gl_Position = position;\n"
            "  color = color0;\n"
            "}\n",
        .fs.source =
            "#version 330\n"
            "in vec4 color;\n"
            "out vec4 frag_color;\n"
            "void main() {\n"
            "  frag_color = color;\n"
            "}\n"
    });

    /* a pipeline state object (default render states are fine for triangle) */
    sg_pipeline pip = sg_make_pipeline(&(sg_pipeline_desc){
        .shader = shd,
        .layout = {
            .attrs = {
                [0].format=SG_VERTEXFORMAT_FLOAT3,
                [1].format=SG_VERTEXFORMAT_FLOAT4
            }
        }
    });

    /* resource bindings */
    sg_bindings binds = {
        .vertex_buffers[0] = vbuf
    };

    /* default pass action (clear to grey) */
    sg_pass_action pass_action = {0};

    /* draw loop */
    while (!glfwWindowShouldClose(w)) {
        int cur_width, cur_height;
        glfwGetFramebufferSize(w, &cur_width, &cur_height);
        sg_begin_default_pass(&pass_action, cur_width, cur_height);
        sg_apply_pipeline(pip);
        sg_apply_bindings(&binds);
        sg_draw(0, 3, 1);
        sg_end_pass();
        sg_commit();
        glfwSwapBuffers(w);
        glfwPollEvents();
    }

    /* cleanup */
    sg_shutdown();
    glfwTerminate();
    return 0;
}

A minimal cross-platform application-wrapper library:

• unified application entry
• single window or canvas for 3D rendering
• 3D context initialization
• event-based keyboard, mouse and touch input
• supported platforms: Win32, MacOS, Linux (X11), iOS, WASM/asm.js, Android (planned: RaspberryPi)
• supported 3D-APIs: GL3.3 (GLX/WGL), Metal, D3D11, GLES2/WebGL, GLES3/WebGL2

A simple clear-loop sample using sokol_app.h and sokol_gfx.h (does not include separate sokol.c/.m implementation file which is necessary to split the Objective-C code from the C code of the sample):

#include "sokol_gfx.h"
#include "sokol_app.h"

sg_pass_action pass_action;

void init(void) {
    sg_setup(&(sg_desc){
        .mtl_device = sapp_metal_get_device(),
        .mtl_renderpass_descriptor_cb = sapp_metal_get_renderpass_descriptor,
        .mtl_drawable_cb = sapp_metal_get_drawable,
        .d3d11_device = sapp_d3d11_get_device(),
        .d3d11_device_context = sapp_d3d11_get_device_context(),
        .d3d11_render_target_view_cb = sapp_d3d11_get_render_target_view,
        .d3d11_depth_stencil_view_cb = sapp_d3d11_get_depth_stencil_view
    });
    pass_action = (sg_pass_action) {
        .colors[0] = { .action=SG_ACTION_CLEAR, .val={1.0f, 0.0f, 0.0f, 1.0f} }
    };
}

void frame(void) {
    float g = pass_action.colors[0].val[1] + 0.01f;
    pass_action.colors[0].val[1] = (g > 1.0f) ? 0.0f : g;
    sg_begin_default_pass(&pass_action, sapp_width(), sapp_height());
    sg_end_pass();
    sg_commit();
}

void cleanup(void) {
    sg_shutdown();
}

sapp_desc sokol_main(int argc, char* argv[]) {
    return (sapp_desc){
        .init_cb = init,
        .frame_cb = frame,
        .cleanup_cb = cleanup,
        .width = 400,
        .height = 300,
        .window_title = "Clear (sokol app)",
    };
}

A minimal audio-streaming API:

• you provide a mono- or stereo-stream of 32-bit float samples which sokol_audio.h forwards into platform-specific backends
• two ways to provide the data:
  1. directly fill backend audio buffer from your callback function running in the audio thread
  2. alternatively push small packets of audio data from your main loop, or a separate thread created by you
• platform backends:
  • Windows: WASAPI
  • macOS/iOS: CoreAudio
  • Linux: ALSA
  • emscripten: WebAudio + ScriptProcessorNode (doesn't use the emscripten-provided OpenAL or SDL Audio wrappers)

A simple mono square-wave generator using the callback model:

// the sample callback, running in audio thread
static void stream_cb(float* buffer, int num_frames, int num_channels) {
    assert(1 == num_channels);
    static uint32_t count = 0;
    for (int i = 0; i < num_frames; i++) {
        buffer[i] = (count++ & (1<<3)) ? 0.5f : -0.5f;
    }
}

int main() {
    // init sokol-audio with default params
    saudio_setup(&(saudio_desc){
        .stream_cb = stream_cb
    });

    // run main loop
    ...

    // shutdown sokol-audio
    saudio_shutdown();
    return 0;

The same code using the push-model

#define BUF_SIZE (32)
int main() {
    // init sokol-audio with default params, no callback
    saudio_setup(&(saudio_desc){0});
    assert(saudio_channels() == 1);

    // a small intermediate buffer so we don't need to push
    // individual samples, which would be quite inefficient
    float buf[BUF_SIZE];
    int buf_pos = 0;
    uint32_t count = 0;

    // push samples from main loop
    bool done = false;
    while (!done) {
        // generate and push audio samples...
        int num_frames = saudio_expect();
        for (int i = 0; i < num_frames; i++) {
            // simple square wave generator
            buf[buf_pos++] = (count++ & (1<<3)) ? 0.5f : -0.5f;
            if (buf_pos == BUF_SIZE) {
                buf_pos = 0;
                saudio_push(buf, BUF_SIZE);
            }
        }
        // handle other per-frame stuff...
        ...
    }

    // shutdown sokol-audio
    saudio_shutdown();
    return 0;
}

Simple cross-platform time measurement:

#include "sokol_time.h"
...
/* initialize sokol_time */
stm_setup();

/* take start timestamp */
uint64_t start = stm_now();

...some code to measure...

/* compute elapsed time */
uint64_t elapsed = stm_since(start);

/* convert to time units */
double seconds = stm_sec(elapsed);
double milliseconds = stm_ms(elapsed);
double microseconds = stm_us(elapsed);
double nanoseconds = stm_ns(elapsed);

/* difference between 2 time stamps */
uint64_t start = stm_now();
...
uint64_t end = stm_now();
uint64_t elapsed = stm_diff(end, start);

/* compute a 'lap time' (e.g. for fps) */
uint64_t last_time = 0;
while (!done) {
    ...render something...
    double frame_time_ms = stm_ms(stm_laptime(&last_time));
}

Unified argument parsing for web and native apps. Uses argc/argv on native platforms and the URL query string on the web.

Example URL with one arg:

https://floooh.github.io/tiny8bit/kc85.html?type=kc85_4

The same as command line app:

kc85 type=kc85_4

Parsed like this:

#include "sokol_args.h"

int main(int argc, char* argv[]) {
    sargs_setup(&(sargs_desc){ .argc=argc, .argv=argv });
    if (sargs_exists("type")) {
        if (sargs_equals("type", "kc85_4")) {
            // start as KC85/4
        }
        else if (sargs_equals("type", "kc85_3")) {
            // start as KC85/3
        }
        else {
            // start as KC85/2
        }
    }
    sargs_shutdown();
    return 0;
}

See the sokol_args.h header for a more complete documentation, and the Tiny Emulators for more interesting usage examples.

A list of things I'd like to do next:

• 2 small additions to the per-pool-slot generation counters in sokol_gfx.h:
  • an sg_setup() option to disable a pool slot when it's generation counter overflows, this makes the dangling-check for resource ids watertight at the cost that the pool will run out of slots at some point
  • instead of the 16/16-bit split in the resource ids for unique-tag vs slot-index, only use as many bits as necessary for the slot-index (based on the number of slots in the pool), and the remaining bits for the unique-tag

Mainly some "missing features" for desktop apps:

• allow 'programmatic quit' requested by the application
• allow to intercept the window close button, so that the app can show a 'do you really want to quit?' dialog box
• define an application icon
• change the window title on existing window
• allow to programmatically activate and deactivate fullscreen
• pointer lock
• show/hide mouse cursor
• allow to change mouse cursor image (at first only switch between system-provided standard images)

• implement an alternative WebAudio backend using Audio Worklets and WASM threads

• 02-May-2019 sokol_gfx.h has a new function sg_query_backend(), this will return an enum sg_backend identifying the backend sokol-gfx is currently running on, which is one of the following values:

  • SG_BACKEND_GLCORE33
  • SG_BACKEND_GLES2
  • SG_BACKEND_GLES3
  • SG_BACKEND_D3D11
  • SG_BACKEND_METAL_MACOS
  • SG_BACKEND_METAL_IOS

  When compiled with SOKOL_GLES3, sg_query_backend() may return SG_BACKEND_GLES2 when the runtime platform doesn't support GLES3/WebGL2 and had to fallback to GLES2/WebGL2.

  When compiled with SOKOL_METAL, sg_query_backend() will return SG_BACKEND_METAL_MACOS when the compile target is macOS, and SG_BACKEND_METAL_IOS when the target is iOS.

• 26-Apr-2019 Small but breaking change in sokol_gfx.h how the vertex layout definition in sg_pipeline_desc works:

  Vertex component names and semantics (needed by the GLES2 and D3D11 backends) have moved from sg_pipeline_desc into sg_shader_desc.

  This may seem like a rather pointless small detail to change, expecially for breaking existing code, but the whole thing will make a bit more sense when the new shader-cross-compiler will be integrated which I'm currently working on (here: https://github.com/floooh/sokol-tools).

  While working on getting reflection data out of the shaders (e.g. what uniform blocks and textures the shader uses), it occured to me that vertex-attribute-names and -semantics are actually part of the reflection info and belong to the shader, not to the vertex layout in the pipeline object (which only describes how the incoming vertex data maps to vertex-component slots. Instead of (optionally) mapping this association through a name, the pipeline's vertex layout is now always strictly defined in terms of numeric 'bind slots' for all sokol_gfx.h backends. For 3D APIs where the vertex component slot isn't explicitely defined in the shader language (GLES2/WebGL, D3D11, and optionally GLES3/GL), the shader merely offers a lookup table how vertex-layout slot-indices map to names/semantics (and the underlying 3D API than maps those names back to slot indices, which shows that Metal and GL made the right choice defining the slots right in the shader).

  Here's how the code changes (taken from the triangle-sapp.c sample):

  OLD:

  /* create a shader */
  sg_shader shd = sg_make_shader(&(sg_shader_desc){
      .vs.source = vs_src,
      .fs.source = fs_src,
  });
  
  /* create a pipeline object (default render states are fine for triangle) */
  pip = sg_make_pipeline(&(sg_pipeline_desc){
      /* if the vertex layout doesn't have gaps, don't need to provide strides and offsets */
      .shader = shd,
      .layout = {
          .attrs = {
              [0] = { .name="position", .sem_name="POS", .format=SG_VERTEXFORMAT_FLOAT3 },
              [1] = { .name="color0", .sem_name="COLOR", .format=SG_VERTEXFORMAT_FLOAT4 }
          }
      },
  });

  NEW:

      /* create a shader */
      sg_shader shd = sg_make_shader(&(sg_shader_desc){
          .attrs = {
              [0] = { .name="position", .sem_name="POS" },
              [1] = { .name="color0", .sem_name="COLOR" }
          },
          .vs.source = vs_src,
          .fs.source = fs_src,
      });
  
      /* create a pipeline object (default render states are fine for triangle) */
      pip = sg_make_pipeline(&(sg_pipeline_desc){
          /* if the vertex layout doesn't have gaps, don't need to provide strides and offsets */
          .shader = shd,
          .layout = {
              .attrs = {
                  [0].format=SG_VERTEXFORMAT_FLOAT3,
                  [1].format=SG_VERTEXFORMAT_FLOAT4
              }
          },
      });

  sg_shader_desc has a new embedded struct attrs which contains a vertex attribute name (for GLES2/WebGL) and sem_name/sem_index (for D3D11). For the Metal backend this struct is ignored completely, and for GLES3/GL it is optional, and not required when the vertex shader inputs are annotated with layout(location=N).

  The remaining attribute description members in sg_pipeline_desc are:

  • .format: the format of input vertex data (this can be different from the vertex shader's inputs when data is extended during vertex fetch (e.g. input can be vec3 while the vertex shader expects vec4)
  • .offset: optional offset of the vertex component data (not needed when the input vertex has no gaps between the components)
  • .buffer: the vertex buffer bind slot if the vertex data is coming from different buffers

  Also check out the various samples:

  • for GLSL (explicit slots via layout(location=N)): https://github.com/floooh/sokol-samples/tree/master/glfw
  • for D3D11 (semantic names/indices): https://github.com/floooh/sokol-samples/tree/master/d3d11
  • for GLES2: (vertex attribute names): https://github.com/floooh/sokol-samples/tree/master/html5
  • for Metal: (explicit slots): https://github.com/floooh/sokol-samples/tree/master/metal
  • ...and all of the above combined: https://github.com/floooh/sokol-samples/tree/master/sapp

• 19-Apr-2019 I have replaced the rather inflexible render-state handling in sokol_gl.h with a pipeline stack (like the GL matrix stack, but with pipeline-state-objects), along with a couple of other minor API tweaks.

  These are the new pipeline-stack functions:

  sgl_pipeline sgl_make_pipeline(const sg_pipeline_desc* desc);
  void sgl_destroy_pipeline(sgl_pipeline pip);
  void sgl_default_pipeline(void);
  void sgl_load_pipeline(sgl_pipeline pip);
  void sgl_push_pipeline(void);
  void sgl_pop_pipeline(void);

  A pipeline object is created just like in sokol_gfx.h, but without shaders, vertex layout, pixel formats, primitive-type and sample count (these details are filled in by the sgl_make_pipeline() wrapper function. For instance to create a pipeline object for additive transparency:

  sgl_pipeline additive_pip = sgl_make_pipeline(&(sg_pipeline_desc){
      .blend = {
          .enabled = true,
          .src_factor_rgb = SG_BLENDFACTOR_ONE,
          .dst_factor_rgb = SG_BLENDFACTOR_ONE
      }
  });

  And to render with this, simply call sgl_load_pipeline():

  sgl_load_pipeline(additive_pip);
  sgl_begin_triangles();
  ...
  sgl_end();

  Or to preserve and restore the previously active pipeline state:

  sgl_push_pipeline();
  sgl_load_pipeline(additive_pip);
  sgl_begin_quads();
  ...
  sgl_end();
  sgl_pop_pipeline();

  You can also load the 'default pipeline' explicitely on the top of the pipeline stack with sgl_default_pipeline().

  The other API change is:

  • sgl_state_texture(bool b) has been replaced with sgl_enable_texture() and sgl_disable_texture()

  The code samples have been updated accordingly:

  • sgl-sapp.c
  • sgl-lines-sapp.c
  • sgl-microui-sapp.c

• 01-Apr-2019 (not an April Fool's joke): There's a new sokol_gl.h util header which implements an 'OpenGL-1.x-in-spirit' rendering API on top of sokol_gfx.h (vertex specification via begin/end, and a matrix stack). This is only a small subset of OpenGL 1.x, mainly intended for debug-visualization or simple tasks like 2D UI rendering. As always, sample code is in the sokol-samples project.

• 15-Mar-2019: various Dear ImGui related changes:

  • there's a new utility header sokol_imgui.h with a simple drop-in renderer for Dear ImGui on top of sokol_gfx.h and sokol_app.h (sokol_app.h is optional, and only used for input handling)
  • the sokol_gfx_imgui.h debug inspection header no longer depends on internal data structures and functions of sokol_gfx.h, as such it is now a normal utility header and has been moved to the utils directory
  • the implementation macro for sokol_gfx_imgui.h has been changed from SOKOL_IMPL to SOKOL_GFX_IMGUI_IMPL (so when you suddenly get unresolved linker errors, that's the reason)
  • all headers now have two preprocessor defines for the declaration and implementation (for instance in sokol_gfx.h: SOKOL_GFX_INCLUDED and SOKOL_GFX_IMPL_INCLUDED) these are checked in the utility-headers to provide useful error message when dependent headers are missing

• 05-Mar-2019: sokol_gfx.h now has a 'trace hook' API, and I have started implementing optional debug-inspection-UI headers on top of Dear ImGui:

  • sokol_gfx.h has a new function sg_install_trace_hooks(), this allows you to install a callback function for each public sokol_gfx.h function (and a couple of error callbacks). For more details, search for "TRACE HOOKS" in sokol_gfx.h
  • when creating sokol_gfx.h resources, you can now set a 'debug label' in the desc structure, this is ignored by sokol_gfx.h itself, but is useful for debuggers or profilers hooking in via the new trace hooks
  • likewise, two new functions sg_push_debug_group() and sg_pop_debug_group() can be used to group related drawing functions under a name, this is also ignored by sokol_gfx.h itself and only useful when hooking into the API calls
  • I have started a new 'subproject' in the 'imgui' directory, this will contain a slowly growing set of optional debug-inspection-UI headers which allow to peek under the hood of the Sokol headers. The UIs are implemented with Dear ImGui. Again, see the README in the 'imgui' directory and the headers in there for details, and check out the live demos on the Sokol Sample Webpage (click on the little UI buttons in the top right corner of each thumbnail)

• 21-Feb-2019: sokol_app.h and sokol_audio.h now have an alternative set of callbacks with user_data arguments. This is useful if you don't want or cannot store your own application state in global variables. See the header documentation in sokol_app.h and sokol_audio.h for details, and check out the samples sapp/noentry-sapp.c and sapp/modplay-sapp.c in https://github.com/floooh/sokol-samples

• 19-Feb-2019: sokol_app.h now has an alternative mode where it doesn't "hijack" the platform's main() function. Search for SOKOL_NO_ENTRY in sokol_app.h for details and documentation.

• 26-Jan-2019: sokol_app.h now has an Android backend contributed by Gustav Olsson! See the sokol-samples readme for build instructions.

• 21-Jan-2019: sokol_gfx.h - pool-slot-generation-counters and a dummy backend:

  • Resource pool slots now have a generation-counter for the resource-id unique-tag, instead of a single counter for the whole pool. This allows to create many more unique handles.
  • sokol_gfx.h now has a dummy backend, activated by defining SOKOL_DUMMY_BACKEND (instead of SOKOL_METAL, SOKOL_D3D11, ...), this allows to write 'headless' tests (and there's now a sokol-gfx-test in the sokol-samples repository which mainly tests the resource pool system)

• 12-Jan-2019: sokol_gfx.h - setting the pipeline state and resource bindings now happens in separate calls, specifically:

  • sg_apply_draw_state() has been replaced with sg_apply_pipeline() and sg_apply_bindings()
  • the sg_draw_state struct has been replaced with sg_bindings
  • sg_apply_uniform_block() has been renamed to sg_apply_uniforms()

All existing code will still work. See this blog post for details.

• 29-Oct-2018:

  • sokol_gfx.h has a new function sg_append_buffer() which allows to append new data to a buffer multiple times per frame and interleave this with draw calls. This basically implements the D3D11_MAP_WRITE_NO_OVERWRITE update strategy for buffer objects. For example usage, see the updated Dear ImGui samples in the sokol_samples repo
  • the GL state cache in sokol_gfx.h handles buffers bindings in a more robust way, previously it might have happened that the buffer binding gets confused when creating buffers or updating buffer contents in the render loop

• 17-Oct-2018: sokol_args.h added

• 26-Sep-2018: sokol_audio.h ready for prime time :)

• 11-May-2018: sokol_gfx.h now autodetects iOS vs MacOS in the Metal backend during compilation using the standard define TARGET_OS_IPHONE defined in the TargetConditionals.h system header, please replace the old backend-selection defines SOKOL_METAL_MACOS and SOKOL_METAL_IOS with SOKOL_METAL

• 20-Apr-2018: 3 new context-switching functions have been added to make it possible to use sokol together with applications that use multiple GL contexts. On D3D11 and Metal, the functions are currently empty. See the new section WORKING WITH CONTEXTS in the sokol_gfx.h header documentation, and the new sample multiwindow-glfw

• 31-Jan-2018: The vertex layout declaration in sg_pipeline_desc had some fairly subtle flaws and has been changed to work like Metal or Vulkan. The gist is that the vertex-buffer-layout properties (vertex stride, vertex-step-rate and -step-function for instancing) is now defined in a separate array from the vertex attributes. This removes some brittle backend code which tries to guess the right vertex attribute slot if no attribute names are given, and which was wrong for shader-code-generation pipelines which reorder the vertex attributes (I stumbled over this when porting the Oryol Gfx module over to sokol-gfx). Some code samples:

// a complete vertex layout declaration with a single input buffer
// with two vertex attributes
sg_pipeline pip = sg_make_pipeline(&(sg_pipeline_desc){
    .layout = {
        .buffers = {
            [0] = {
                .stride = 20,
                .step_func = SG_VERTEXSTEP_PER_VERTEX,
                .step_rate = 1
            }
        },
        .attrs = {
            [0] = {
                .name = "pos",
                .offset = 0,
                .format = SG_VERTEXFORMAT_FLOAT3,
                .buffer_index = 0
            },
            [1] = {
                .name = "uv",
                .offset = 12,
                .format = SG_VERTEXFORMAT_FLOAT2,
                .buffer_index = 0
            }
        }
    },
    ...
});

// if the vertex layout has no gaps, we can get rid of the strides and offsets:
sg_pipeline pip = sg_make_pipeline(&(sg_pipeline_desc){
    .layout = {
        .buffers = {
            [0] = {
                .step_func = SG_VERTEXSTEP_PER_VERTEX,
                .step_rate=1
            }
        },
        .attrs = {
            [0] = {
                .name = "pos",
                .format = SG_VERTEXFORMAT_FLOAT3,
                .buffer_index = 0
            },
            [1] = {
                .name = "uv",
                .format = SG_VERTEXFORMAT_FLOAT2,
                .buffer_index = 0
            }
        }
    },
    ...
});

// we can also get rid of the other default-values, which leaves buffers[0]
// as all-defaults, so it can disappear completely:
sg_pipeline pip = sg_make_pipeline(&(sg_pipeline_desc){
    .layout = {
        .attrs = {
            [0] = { .name = "pos", .format = SG_VERTEXFORMAT_FLOAT3 },
            [1] = { .name = "uv", .format = SG_VERTEXFORMAT_FLOAT2 }
        }
    },
    ...
});

// and finally on GL3.3 and Metal and we don't need the attribute names
// (on D3D11, a semantic name and index must be provided though)
sg_pipeline pip = sg_make_pipeline(&(sg_pipeline_desc){
    .layout = {
        .attrs = {
            [0] = { .format = SG_VERTEXFORMAT_FLOAT3 },
            [1] = { .format = SG_VERTEXFORMAT_FLOAT2 }
        }
    },
    ...
});

Please check the sample code in https://github.com/floooh/sokol-samples for more examples!

Enjoy!