Skip is a reactive backend where the framework keeps the dependencies for you

One repository holds three products

The repository contains the Skip Framework for building reactive backend services, the Skiplang toolchain that powers its native runtime, and SKDB, a reactive SQL database built on Skip. The contents are laid out to match, with the framework and its TypeScript runtime under `skipruntime-ts/`, the compiler and its tooling under `skiplang/`, and the database client, server and runtime under `sql/`. There is also an `ide/` directory, an `rfc/` directory for design documents, a `www/` directory for the documentation site, and a `packages/` directory for the shared workspace packages. The description of the framework is that it is based on a custom-built native backend for efficient reactive computation, allowing your system to deliver up-to-date and correct results without requiring any bug-prone manual dependency tracking and updating.

The install is an npm package with a runtime choice

Getting started means installing one npm package:

npm install @skiplabs/skip

The runtime itself comes in two versions, a Wasm `@skipruntime/wasm` and a native `@skipruntime/native`. The Wasm runtime is installed by default and it works with both `node` and `bun`, but it is limited to Wasm's 32-bit memory address space. The native runtime does not have that limitation, but the documentation says it is a bit more involved to install and points to the INSTALL.md file for the instructions. The choice is a real one rather than a packaging detail, because the 32-bit address space is a hard ceiling on how much data a service can hold, and a service that reads a large table would hit it. The framework exposes TypeScript interfaces and abstractions, so you write a reactive service using standard tools while taking advantage of the framework's abstractions for efficient reactivity.

The native runtime is a compiled language, not an interpreter

The native runtime is implemented in Skiplang, and the compiler, runtime and surrounding tools live under the `skiplang/` directory, including `skargo` and `sktest`, with INSTALL.md carrying the instructions for building the toolchain from source. The repository layout shows how deep the language goes, with a `prelude/` directory holding the standard library bindings for the different targets, and separate `ts/` subdirectories for the binding, the wasm and the worker variants, plus `skdate` and `skjson` for dates and JSON. The Makefile drives the whole thing, with the `skargo` profile controlling the build type, and the SKDB wasm binary is built with `skargo build --target wasm32-unknown-unknown --bin skdb`. The Docker build is a multi-stage one that compiles the compiler with clang and clang++ on an Ubuntu 24.04 base, with a `SKIP_CAPACITY` build argument that can be set to fit the build host's memory budget, since the runtime's own default is 16 GB for local dev builds.

SKDB is a reactive database in the same ecosystem

SKDB is a reactive SQL database and part of the Skip ecosystem, with the TypeScript client published as the `skdb` npm package and the sources for the client, server and runtime under `sql/`. The Makefile shows how the pieces are produced, with a target that builds the wasm binary and the JavaScript client, assembles the publishable layout from `sql/ts`, and then installs it into a scaffolded node_modules to smoke-test a consumer install. The comment on that target is telling, because it says the assembled directory mirrors what publishing from `sql/ts` would ship, and that it is consumed by the vite check and the bun test, which copy it into a scaffolded node_modules. In other words, the project checks that the published package actually works, not just that the source compiles.

The examples show what a deployment looks like

There are two levels of example, and the second one is the more instructive. The smaller ones, under `skipruntime-ts/examples/`, demonstrate patterns of reactive programming. The `examples/` directory at the top level contains four complete applications: a blogger, a cache invalidation example with an edge service, a chatroom, and a HackerNews example. The HackerNews one is described as designed to serve as an example of how to deploy and configure a reactive service, using Docker compose to package and orchestrate a backend made up of a reactive service, a database, a backend web service and a reverse proxy. That last part is the point. A reactive framework is only interesting once you have seen how the invalidation, the database and the HTTP layer interact, and the cache invalidation example is the one that would tell you whether the model fits your problem.

The workspace shape and the release cadence

The root package.json is a workspace manifest listing around thirty members, and the layout mirrors the three products: the skipruntime-ts packages for the core, helpers, wasm, addon, the Kafka and Postgres adapters, the server and the metapackage, the skiplang prelude and the skdate and skjson TypeScript packages, the sql/ts client and its tests, and then one example workspace per application, each with its own reactive service and, for HackerNews, an edge service. The top level scripts are thin, with build, clean, lint and test all fanning out across the workspaces with `--if-present`, which is the standard way to run a monorepo's checks without a custom orchestrator. The release history shows the framework at version 0.0.19, published in November 2025, after 0.0.18 and 0.0.17 in the days before it, and the last push to the main branch was on 2026-10-09. The version numbers below one point are the honest signal here, and the licence is MIT.

Editorial conclusion

Adopt Skip if you are building a backend where derived state has to stay correct under change, since the whole premise is that the framework tracks dependencies so you do not have to. Do not adopt it if you need a full production deployment today without accepting a young toolchain, because the runtime, the language and the database are all part of one repository. Verify first whether the WebAssembly runtime is enough for your data size, since it is limited to the 32-bit memory address space, and read INSTALL.md before choosing the native runtime.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. SkipLabs/skip on GitHub