Getting Started

Requirements

To build and run Scrii from source you need:

• A C++23 compiler — GCC 13+, Clang 16+, or MSVC.
• CMake 3.20+.

Optional native backends are detected and enabled automatically when the corresponding library is available:

• OpenSSL — crypto (std.crypto) and TLS.
• zstd and lz4 — compression (std.compression).
• libpng, libjpeg, and zlib — image and data handling.

If a backend is absent, the matching module still compiles but its functions throw UNSUPPORTED at runtime.

Building Scrii

git clone https://codefloe.com/okina/scrii.git
cd scrii
cmake -S . -B build
cmake --build build -j

By default this produces two things:

• build/interpreter/scrii_repl — the interpreter / REPL.
• libScrii.a — the static language library for embedding.

Both are built with Release (-O3) out of the box, so the interpreter runs at full speed — no extra flags needed. (If you want a debug build, set -DCMAKE_BUILD_TYPE=Debug yourself.)

Optional build components

The super-build controls what gets built. Everything is off by default except the interpreter and the core library:

Option	Default	Build	Purpose
PACKAGE_INTERPRETER	ON	cmake --build build --target scrii_repl	Interpreter / REPL
PACKAGE_TESTS	ON	cmake --build build --target test	Unit test suite
PACKAGE_BENCHMARKS	OFF	-DPACKAGE_BENCHMARKS=ON	Micro-benchmark tools

Examples:

# build and run the tests
cmake --build build --target test

# build the micro-benchmarks
cmake -S . -B build -DPACKAGE_BENCHMARKS=ON
cmake --build build --target benchmarks

# interpreter-only build (skip tests)
cmake -S . -B build -DPACKAGE_TESTS=OFF

Tooling

Editor tooling ships in separate repositories and is built independently of the interpreter:

• Tooling — scrii_fmt, scrii_ls, and tree-sitter-scrii.

Using Scrii as a dependency

Embed the Scrii core into your own C++ project. See Embedding for the full host API.

CMake

The core ships an integration helper, ScriiCore.cmake, that builds the Scrii static library with the optional native backends (OpenSSL, zlib, zstd, lz4, libpng, libjpeg) auto-detected. Pull the repo and add the core library to your project:

include(FetchContent)

FetchContent_Declare(scrii
  GIT_REPOSITORY https://codefloe.com/okina/scrii.git
  GIT_TAG        v0.1.0  # or main for the latest development snapshot
)
FetchContent_MakeAvailable(scrii)

include(${scrii_SOURCE_DIR}/cmake/ScriiCore.cmake)
scrii_add_core_library()

add_executable(my_app main.cpp)
target_link_libraries(my_app PRIVATE Scrii)

Notes:

• scrii_add_core_library() is a no-op if a Scrii target already exists, so a superproject and a standalone component can coexist without conflict.
• Scrii compiles with C++23 and carries its public include directory (src/) and the compile definitions SCRII_VERSION / SCRII_BUILD_DATE.
• Backends are optional: OpenSSL, ZLIB, PNG, and JPEG are detected via find_package; zstd and lz4 via find_path/find_library. When a backend is absent the corresponding std module still compiles, but its functions throw status::UNSUPPORTED at runtime. See the build messages from ScriiCore.cmake to see which were enabled.

Meson

Scrii's build is CMake-based, and its top-level CMakeLists.txt builds the interpreter, tests, and benchmarks around the core. For Meson the simplest reliable route is to compile the core directly — it is a small static library whose sources are all .cpp files under src/ (the two entry points are src/scrii.cpp and src/plugin.cpp, plus the parser/, thread/, std/, etc. trees that make up the interpreter). Add a subprojects/scrii.wrap:

[wrap-git]
url = https://codefloe.com/okina/scrii.git
revision = v0.1.0
depth = 1

Then a subprojects/scrii/meson.build that globs the sources and exposes a dependency:

project('scrii', 'cpp')

scrii_inc = include_directories('src')

src = run_command(
  'sh', '-c', 'find src -name "*.cpp" | sort',
  check: true,
).stdout().strip().split('\n')

scrii_lib = static_library('scrii',
  src,
  include_directories: scrii_inc,
  cpp_args: ['-DSCRII_VERSION="' + meson.project_version() + '"',
             '-DSCRII_BUILD_DATE="' + run_command('date', '+%Y-%m-%d').stdout().strip() + '"'],
)

scrii_dep = declare_dependency(
  include_directories: scrii_inc,
  link_with: scrii_lib,
)

Use it from your project's meson.build:

project('my_app', 'cpp', default_options: ['cpp_std=c++23'])

scrii_dep = subproject('scrii').get_variable('scrii_dep')

executable('my_app', 'main.cpp', dependencies: scrii_dep)

Notes for the direct-compile route:

• Backends. The CMake route auto-detects OpenSSL/zlib/libpng/libjpeg via find_package, and zstd/lz4 via find_path/find_library. In Meson you must add the equivalent dependency() calls yourself and define the matching SCRII_HAVE_* macros, or skip them — the correlating std module then throws UNSUPPORTED at runtime. See cmake/ScriiCore.cmake for the exact macro names and link libraries.
• Include path. scrii_inc points at src/ so #include "scrii.hpp" and the private headers under src/ resolve directly.

Running scripts

Run a file:

./build/interpreter/scrii_repl examples/01_hello_world/hello.scr

Start an interactive REPL:

./build/interpreter/scrii_repl

scrii interactive interpreter (Ctrl-D or :quit to exit)
> var x = 40 + 2
> print(x)
42

Your first program

Create hello.scr:

// comments are C-style
var name = "Scrii"

fn greet(who) {
  return "Hello, " + who + "!"
}

print(greet(name))
print("type of name:", type(name))

Save it and run:

./build/interpreter/scrii_repl hello.scr

Hello, Scrii!
type of name: string

Running the examples

The repository ships a set of runnable examples under examples/:

./build/interpreter/scrii_repl examples/02_types/types.scr
./build/interpreter/scrii_repl examples/04_functions/functions.scr
./build/interpreter/scrii_repl examples/13_imports/import_example.scr
./build/interpreter/scrii_repl examples/14_async/async.scr
./build/interpreter/scrii_repl examples/25_http/http.scr

A complete hello-world style tour lives in examples/01_hello_world/.